astro.config.ts

import { createRequire } from "node:module";
import { readdir, readFile, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { defineConfig } from "astro/config";
import type { AstroIntegration } from "astro";
import { generateAPIReferenceItems, stainlessDocs } from "@stainless-api/docs";
import starlightLlmsTxt from "starlight-llms-txt";
import rehypeBasePath from "./src/plugins/rehype-base-path";
import rehypePagefindWeight from "./src/plugins/rehype-pagefind-weight";
import remarkResolveConstantsInHeadings from "./src/plugins/remark-resolve-constants-in-headings";

import sentry from "@sentry/astro";

const require = createRequire(import.meta.url);

// Resolve package subpaths so aliasing the main "components" entry doesn't break ThemeSelect/SDKSelect.
const docsComponentsScriptsPath = require.resolve("@stainless-api/docs/components/scripts");

/**
 * Vite 7 compat:
 *
 * 1) Some plugins declare `transform`/`load`/`resolveId` as `{ filter }` without a
 *    `handler`, which crashes EnvironmentPluginContainer when it calls handler.call().
 *    We patch hooks in `config` + `configResolved` (below).
 *
 * 2) Plugins such as `@vitejs/plugin-react` may delete `transform` in `configResolved`
 *    after Vite has cached which plugins expose `transform`, so `getHookHandler` returns
 *    undefined and handler.call() throws (upstream: vitejs/vite#21162). We ship a pnpm
 *    patch for `vite@7.3.1` (`patches/vite@7.3.1.patch`) that skips when `!handler`.
 */
const HOOK_NAMES = ["transform", "load", "resolveId"] as const;
const noopHandlers: Record<(typeof HOOK_NAMES)[number], () => null> = {
  transform: () => null,
  load: () => null,
  resolveId: () => null,
};

function patchHook(hook: unknown, hookName: (typeof HOOK_NAMES)[number]): unknown {
  // Vite's getHookHandler(hook) returns hook.handler when hook is an object, else hook.
  // If a plugin has transform: { filter } with no handler, getHookHandler returns undefined and handler.call() throws.
  if (hook === undefined || hook === null) {
    return { handler: noopHandlers[hookName] };
  }
  if (
    typeof hook === "object" &&
    typeof (hook as { handler?: unknown }).handler !== "function"
  ) {
    return { ...(hook as object), handler: noopHandlers[hookName] };
  }
  if (typeof hook !== "function") {
    return { handler: noopHandlers[hookName] };
  }
  return hook;
}

function createPluginProxy(plugin: Record<string, unknown>): Record<string, unknown> {
  return new Proxy(plugin, {
    get(target, prop: string) {
      const value = target[prop];
      if (HOOK_NAMES.includes(prop as (typeof HOOK_NAMES)[number])) {
        return patchHook(value, prop as (typeof HOOK_NAMES)[number]);
      }
      return value;
    },
  });
}

function patchAllPlugins(plugins: unknown[]): void {
  if (!Array.isArray(plugins)) return;
  for (const plugin of plugins as Record<string, unknown>[]) {
    if (plugin && typeof plugin === "object") {
      for (const hookName of HOOK_NAMES) {
        const hook = plugin[hookName];
        if (
          hook &&
          typeof hook === "object" &&
          typeof (hook as { handler?: unknown }).handler !== "function" &&
          typeof hook !== "function"
        ) {
          (plugin as Record<string, unknown>)[hookName] = {
            ...(hook as object),
            handler: noopHandlers[hookName],
          };
        }
      }
    }
  }
}

function vite7CompatPlugin(): {
  name: string;
  enforce: "post";
  config: (config: { plugins?: unknown[] }) => { plugins?: unknown[] };
  configResolved: (config: { plugins: unknown[] }) => void;
} {
  return {
    name: "vite7-compat-patch-hooks",
    enforce: "post",
    config(config: { plugins?: unknown[] }) {
      patchAllPlugins(config.plugins ?? []);
      return {};
    },
    configResolved(config: { plugins: unknown[] }) {
      // In-place patch only. Replacing config.plugins with proxy-wrapped plugins can break
      // Astro virtual modules (e.g. astro:server-app). patchAllPlugins mutates hook objects
      // so transform/load/resolveId have a callable handler when they were missing one.
      patchAllPlugins(config.plugins ?? []);
    },
  };
}

/**
 * Post-build safety net: walks every generated .html file and prefixes
 * root-relative hrefs on <a>, <area>, and <link> elements with the base path.
 * No-op when BASE is "/".
 */
function basePathPostProcessor(base: string): AstroIntegration {
  const prefix = base.replace(/\/$/, "");
  return {
    name: "base-path-post-processor",
    hooks: prefix
      ? {
          "astro:build:done": async ({ dir }) => {
            const outDir = dir.pathname;
            const htmlFiles = await collectHtmlFiles(outDir);
            let totalReplaced = 0;
            for (const file of htmlFiles) {
              const html = await readFile(file, "utf-8");
              let count = 0;
              const updated = html.replace(
                /(<(?:a|area|link)\b[^>]*?\bhref=")(\/)([^"]*")/gi,
                (_match, before, _slash, rest) => {
                  const href = "/" + rest.slice(0, -1); // reconstruct full href (without trailing quote)
                  if (href.startsWith(prefix + "/") || href === prefix) {
                    return _match; // already prefixed
                  }
                  count++;
                  return before + prefix + "/" + rest;
                }
              );
              if (count > 0) {
                await writeFile(file, updated, "utf-8");
                totalReplaced += count;
              }
            }
            console.log(
              `[base-path-post-processor] Prefixed ${totalReplaced} href(s) across ${htmlFiles.length} HTML file(s).`
            );
          },
        }
      : {},
  };
}

async function collectHtmlFiles(dir: string): Promise<string[]> {
  const results: string[] = [];
  const entries = await readdir(dir, { withFileTypes: true });
  for (const entry of entries) {
    const fullPath = join(dir, entry.name);
    if (entry.isDirectory()) {
      results.push(...(await collectHtmlFiles(fullPath)));
    } else if (entry.name.endsWith(".html")) {
      results.push(fullPath);
    }
  }
  return results;
}

// Base path from env var (e.g. BASE_PATH="/docs"). Falls back to "/" (no subpath).
const BASE = process.env.BASE_PATH || "/";

/**
 * Set `DOCS_LOCAL_WITHOUT_STAINLESS=1` to run `pnpm dev` / `pnpm build` without a
 * Stainless API key or `stl auth login`. Tiger Cloud REST API pages are omitted;
 * use a stub page and redirects instead (see README).
 */
const DOCS_LOCAL_WITHOUT_STAINLESS =
  process.env.DOCS_LOCAL_WITHOUT_STAINLESS === "1" ||
  process.env.DOCS_LOCAL_WITHOUT_STAINLESS === "true";

/** Astro doesn't auto-prepend `base` to redirect destinations. This helper does. */
function withBase(redirects: Record<string, string>): Record<string, string> {
  if (BASE === "/") return redirects;
  return Object.fromEntries(
    Object.entries(redirects).map(([from, to]) => [from, BASE + to])
  );
}

// ESM dynamic import: starlight-links-validator ships TypeScript; `require()` fails on Node 22+
// ("Stripping types is currently unsupported for files under node_modules").
const starlightLinksValidator = process.env.CHECK_LINKS
  ? (await import("starlight-links-validator")).default
  : null;

// https://astro.build/config
export default defineConfig({
  site: 'https://www.tigerdata.com',
  base: BASE,
  trailingSlash: "never",
  markdown: {
    gfm: true,
    remarkPlugins: [remarkResolveConstantsInHeadings],
    rehypePlugins: [[rehypeBasePath, { base: BASE }], rehypePagefindWeight],
  },
    vite: {
      plugins: [vite7CompatPlugin()] as any,
      resolve: {
        alias: [
          { find: "@components", replacement: new URL("./src/components", import.meta.url).pathname },
          { find: "@constants", replacement: new URL("./src/constants.ts", import.meta.url).pathname },
          // Resolve scripts subpath to the package so ThemeSelect.astro / SDKSelect.astro keep working.
          {
            find: "@stainless-api/docs/components/scripts",
            replacement: docsComponentsScriptsPath,
          },
          // Override Callout with our Figma-styled Tip (lightbulb icon). Exact match only.
          {
            find: /^@stainless-api\/docs\/components$/,
            replacement: new URL("./src/lib/docs-components.ts", import.meta.url).pathname,
          },
        ],
      },
    },
    integrations: [basePathPostProcessor(BASE), stainlessDocs({
      apiReference: DOCS_LOCAL_WITHOUT_STAINLESS
        ? null
        : {
            stainlessProject: "tiger-cloud",
            basePath: "/reference/tiger-cloud-rest",
            // Workaround to hide default TypeScript reference in the API reference page. It's showing the TypeScript lib even without have a Typescript SDK published.
            excludeLanguages: ["typescript"],
            propertySettings: {
              collapseDescription: false,
              expandDepth: 2,
            },
          },
      title: "Tiger Data Docs",
      logo: {
        light: "./src/assets/logo-light.svg",
        dark: "./src/assets/logo-dark.svg",
        alt: "Tiger Data",
        replacesTitle: true,
      },
      favicon: "favicon.ico",
      customCss: ["./theme.css", "./osano.css", "./src/styles/layout-root.css"],
      lastUpdated: true,
      // Adds a "Suggest an edit to this page" link in the footer of every content
      // page, pointing at the page's Markdown source on GitHub. Starlight appends the
      // page's source path (relative to the repo root) to this base URL, so the link
      // opens GitHub's editor for that exact file. Auto-generated pages (the Tiger
      // Cloud REST reference) have no source file, so no link is rendered for them.
      editLink: {
        baseUrl: "https://github.com/timescale/Tiger-Data-Docs/edit/main/",
      },
      head: [
        {
          // Segment
          tag: "script",
          content: `!function(){function isBot(){if(typeof navigator==='undefined'||!navigator.userAgent)return true;var ua=navigator.userAgent.toLowerCase();var botPatterns=['bot','crawler','spider','crawling','slurp','bingpreview','facebookexternalhit','facebot','twitterbot','rogerbot','linkedinbot','embedly','quora link preview','showyoubot','outbrain','pinterest','developers.google.com/+/web/snippet','slackbot','vkshare','w3c_validator','redditbot','applebot','whatsapp','flipboard','tumblr','bitlybot','skypeuripreview','nuzzel','discordbot','google page speed','qwantify','pinterestbot','bitrix link preview','xing-contenttabreceiver','chrome-lighthouse','telegrambot','headlesschrome','phantom','baiduspider','baiduspider-render','yandexbot','duckduckbot','ahrefsbot','semrushbot','dotbot','mj12bot','petalbot','gptbot','chatgpt','claudebot','claude-web','anthropic-ai','google-extended','cohere-ai','omgilibot','omgili','facebookbot','meta-externalagent','diffbot','bytespider','perplexitybot','youbot','ai2bot','ccbot','dataforseobotd'];return botPatterns.some(function(pattern){return ua.indexOf(pattern)!==-1})}if(isBot()){console.debug('Bot detected, skipping Segment analytics');return}var i="analytics",analytics=window[i]=window[i]||[];if(!analytics.initialize)if(analytics.invoked)window.console&&console.error&&console.error("Segment snippet included twice.");else{analytics.invoked=!0;analytics.methods=["trackSubmit","trackClick","trackLink","trackForm","pageview","identify","reset","group","track","ready","alias","debug","page","screen","once","off","on","addSourceMiddleware","addIntegrationMiddleware","setAnonymousId","addDestinationMiddleware","register"];analytics.factory=function(e){return function(){if(window[i].initialized)return window[i][e].apply(window[i],arguments);var n=Array.prototype.slice.call(arguments);if(["track","screen","alias","group","page","identify"].indexOf(e)>-1){var c=document.querySelector("link[rel='canonical']");n.push({__t:"bpc",c:c&&c.getAttribute("href")||void 0,p:location.pathname,u:location.href,s:location.search,t:document.title,r:document.referrer})}n.unshift(e);analytics.push(n);return analytics}};for(var n=0;n<analytics.methods.length;n++){var key=analytics.methods[n];analytics[key]=analytics.factory(key)}analytics.load=function(key,n){var t=document.createElement("script");t.type="text/javascript";t.async=!0;t.setAttribute("data-global-segment-analytics-key",i);t.src="https://cdn.segment.com/analytics.js/v1/"+key+"/analytics.min.js";var r=document.getElementsByTagName("script")[0];r.parentNode.insertBefore(t,r);analytics._loadOptions=n};analytics._writeKey="CF77jkjlE82B4PhIHbbMDiSmOJsDYMqF";analytics.SNIPPET_VERSION="5.2.0";analytics.load("CF77jkjlE82B4PhIHbbMDiSmOJsDYMqF");analytics.page()}}();`,
        },
        {
          // GTM
          tag: "script",
          content: `
            (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
            new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
            j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
            'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
            })(window,document,'script','dataLayer','GTM-PFLX3HP');
          `,
        },
        {
          // Twitter/X ads pixel
          tag: "script",
          content: `!function(e,t,n,s,u,a){e.twq||(s=e.twq=function(){s.exe?s.exe.apply(s,arguments):s.queue.push(arguments);},s.version='1.1',s.queue=[],u=t.createElement(n),u.async=!0,u.src='//static.ads-twitter.com/uwt.js',a=t.getElementsByTagName(n)[0],a.parentNode.insertBefore(u,a))}(window,document,'script');twq('init','o8fs3');twq('track','PageView');`,
        },
        {
          // Sidebar active-branch expander: Starlight persists open/closed sidebar
          // groups in sessionStorage and restores them on load, which can override the
          // server-rendered open state and leave the current page hidden inside a
          // collapsed parent group (e.g. a page nested one level down in a subgroup).
          // After the persister runs, force every <details> ancestor of the active link
          // open so the current page is always revealed. Setting `.open` directly does
          // not fire the persister's click handler, so no loop or stored-state changes.
          tag: "script",
          content: `(function(){function exp(){var b=document.getElementById("starlight__sidebar");if(!b)return;var a=b.querySelector('[aria-current="page"]');if(!a)return;var e=a.parentElement;while(e&&e!==b){if(e.tagName==="DETAILS")e.open=true;e=e.parentElement;}}if(document.readyState==="loading"){document.addEventListener("DOMContentLoaded",exp);}else{exp();}document.addEventListener("astro:page-load",exp);})();`,
        },
        // ──── BEGIN STATSIG ────
        // Statsig client-side SDK: session replay, web analytics, and gate exposure logging.
        // Uses Segment's ajs_anonymous_id cookie for user identification.
        // TO REMOVE: see README-statsig.md for full cleanup instructions.
        // Gate: new_docs_site_rollout — https://console.statsig.com/2aVMoalsJmTVASIsy8WxBu/gates/new_docs_site_rollout
        // Env var: PUBLIC_STATSIG_CLIENT_KEY (set in Vercel + .env.local)
        {
          tag: "script",
          content: `!function(){try{var k="${import.meta.env.PUBLIC_STATSIG_CLIENT_KEY}";if(!k||k==="undefined"){console.debug("Statsig: no client key, skipping");return}var e=document.cookie.match(/ajs_anonymous_id=([^;]+)/);if(e&&e[1]){var t=document.createElement("script");t.async=!0;t.src="https://cdn.jsdelivr.net/npm/@statsig/js-client@3/build/statsig-js-client+session-replay+web-analytics.min.js";t.onload=function(){try{var s=new window.__STATSIG__.StatsigClient(k,{userID:decodeURIComponent(e[1])});s.initializeAsync().then(function(){s.checkGate("new_docs_site_rollout")})}catch(err){console.debug("Statsig init error:",err)}};document.head.appendChild(t)}}catch(err){console.debug("Statsig setup error:",err)}}();`,
        },
        // ──── END STATSIG ────
        // ──── BEGIN POSTHOG ────
        // PostHog product analytics. The project API key (phc_...) is public and
        // safe to ship in client-side code, so it's hardcoded here.
        {
          tag: "script",
          content: `!function(t,e){var o,n,p,r;e.__SV||(window.posthog && window.posthog.__loaded)||(window.posthog=e,e._i=[],e.init=function(i,s,a){function g(t,e){var o=e.split(".");2==o.length&&(t=t[o[0]],e=o[1]),t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}}(p=t.createElement("script")).type="text/javascript",p.crossOrigin="anonymous",p.async=!0,p.src=s.api_host.replace(".i.posthog.com","-assets.i.posthog.com")+"/static/array.js",(r=t.getElementsByTagName("script")[0]).parentNode.insertBefore(p,r);var u=e;for(void 0!==a?u=e[a]=[]:a="posthog",u.people=u.people||[],u.toString=function(t){var e="posthog";return"posthog"!==a&&(e+="."+a),t||(e+=" (stub)"),e},u.people.toString=function(){return u.toString(1)+".people (stub)"},o="ki Ci init qi Hi pr ji zi Di capture calculateEventProperties Qi register register_once register_for_session unregister unregister_for_session Ki getFeatureFlag getFeatureFlagPayload getFeatureFlagResult getAllFeatureFlags isFeatureEnabled reloadFeatureFlags updateFlags updateEarlyAccessFeatureEnrollment getEarlyAccessFeatures on onFeatureFlags onSurveysLoaded onSessionId getSurveys getActiveMatchingSurveys renderSurvey displaySurvey cancelPendingSurvey canRenderSurvey canRenderSurveyAsync Xi identify setPersonProperties unsetPersonProperties group resetGroups setPersonPropertiesForFlags resetPersonPropertiesForFlags setGroupPropertiesForFlags resetGroupPropertiesForFlags reset setIdentity clearIdentity get_distinct_id getGroups get_session_id get_session_replay_url alias set_config startSessionRecording stopSessionRecording sessionRecordingStarted captureException addExceptionStep captureLog startExceptionAutocapture stopExceptionAutocapture loadToolbar get_property getSessionProperty Ji Gi createPersonProfile setInternalOrTestUser Yi Ai rn opt_in_capturing opt_out_capturing has_opted_in_capturing has_opted_out_capturing get_explicit_consent_status is_capturing clear_opt_in_out_capturing Vi debug mr it getPageViewId captureTraceFeedback captureTraceMetric Oi".split(" "),n=0;n<o.length;n++)g(u,o[n]);e._i.push([i,s,a])},e.__SV=1)}(document,window.posthog||[]);posthog.init('phc_OsZpGzq2LBW8OMXjdktxavhYkehe8R05zsW0zN6prLF',{api_host:'https://us.i.posthog.com',defaults:'2026-05-30',person_profiles:'identified_only'});`,
        },
        // ──── END POSTHOG ────
      ],
      header: {
        layout: "stacked",
        links: [
          {
            label: "Get started",
            link: "/get-started",
          },
        ],
      },
      // social: [
      //   { icon: "github", label: "GitHub", href: "https://github.com/timescale/timescaledb" },
      // ],
      experimental: {
        ...(DOCS_LOCAL_WITHOUT_STAINLESS ? { disableStainlessProseIndexing: true } : {}),
        starlightCompat: {
          components: {
            Head: "./src/components/Head.astro",
            Header: "./src/components/Header.astro",
            MobileMenuToggle: "./src/components/MobileMenuToggle.astro",
            PageTitle: "./src/components/PageTitle.astro",
            PageSidebar: "./src/components/PageSidebar.astro",
            Pagination: "./src/components/PageNavigation.astro",
            Callout: "./src/components/Callout.astro",
            Footer: "./src/components/Footer.astro",
          } as Record<string, string>,
          /** Single-link sidebar groups become one clickable row (see `src/starlight-route-middleware.ts`). */
          routeMiddleware: ["./src/starlight-route-middleware.ts"],
          plugins: [
              starlightLlmsTxt(),
              ...(starlightLinksValidator
                ? [starlightLinksValidator({
                    // The Tiger Cloud REST API reference is auto-generated by the
                    // Stainless docs integration and only exists when STAINLESS_API_KEY
                    // is set. Exclude its paths so lint:links passes without the key.
                    exclude: ["/reference/tiger-cloud-rest/**", "/files/**"],
                  })]
                : []),
            ],
        },
      },
      tabs: [
        // Get Started tab
        {
          label: "Get started",
          link: "/get-started",
          sidebar: [
            "get-started", // Welcome/index page
            {
              label: "Choose your setup",
              collapsed: true,
              items: [
                { label: "Compare Tiger Data products", link: "/get-started/feature-comparison" },
                { label: "Cloud-exclusive features", link: "/get-started/cloud-exclusive-features" },
                { label: "Compare TimescaleDB editions", link: "/get-started/choose-your-path/timescaledb-editions" },
              ],
            },
            {
              label: "Tiger Console",
              collapsed: true,
              items: [
                { label: "5-minute quickstart", link: "/get-started/quickstart/quickstart-5-minutes" },
                { label: "Create a Tiger Cloud service", link: "/get-started/quickstart/create-service" },
                { label: "Supported regions", link: "/get-started/supported-regions" },
              ],
            },
            {
              label: "Tiger CLI and MCP",
              collapsed: true,
              items: [
                { label: "Get started with Tiger CLI", link: "/get-started/quickstart/tiger-cli" },
                { label: "Integrate Tiger Cloud with your AI agent", link: "/get-started/quickstart/mcp-cli" },
                { label: "Get started with the REST API", link: "/get-started/quickstart/rest-api" },
              ],
            },
            {
              label: "Self-hosted TimescaleDB",
              collapsed: true,
              items: [
                { label: "10-minute quickstart", link: "/get-started/quickstart/timescaledb-quickstart" },
                { label: "Install self-hosted TimescaleDB", link: "/get-started/choose-your-path/install-timescaledb" },
                { label: "Connect your app", link: "/get-started/quickstart/connect-your-app" },
                { label: "Supported platforms", link: "/get-started/timescaledb-supported-platforms" },
              ],
            },
            {
              label: "News and updates",
              collapsed: true,
              autogenerate: { directory: "get-started/news" },
            },
            {
              label: "Contribute to docs",
              collapsed: true,
              items: [{ label: "How to contribute", link: "/get-started/contributing" }],
            },
          ],
        },
        // Learn tab: conceptual and overview content lives under /learn/. Hands-on how-tos link to /build/.
        // Learn sidebar: groups follow dependency order. Retention + tiering: one "Data lifecycle" group. Chunks + time buckets: one "Chunks and time buckets" group (not nested under Hypertables). CAGGs: one "Continuous aggregates (CAGGs)" group (Tiger Cloud nested; backfill migration tool at end; "About CAGGs" omitted from nav, linked from overview).
        {
          label: "Learn",
          link: "/learn",
          sidebar: [
            {
              label: "Overview",
              collapsed: true,
              items: [
                { label: "What is Tiger Data", link: "/learn" },
                { label: "Tiger Data architecture for real-time analytics", link: "/learn/deep-dive/whitepaper" },
              ],
            },
            {
              label: "Tiger Cloud",
              collapsed: true,
              items: [
                { label: "Tiger Cloud", link: "/learn/tiger-cloud" },
                { label: "Cloud-exclusive features", link: "/learn/tiger-cloud/cloud-exclusive-features" },
                { label: "Tiger Cloud essentials", link: "/learn/tiger-cloud/tiger-cloud-essentials" },
              ],
            },
            {
              label: "Tiger CLI and MCP",
              collapsed: true,
              items: [
                { label: "Tiger CLI and Tiger MCP", link: "/learn/tiger-cli-mcp" },
              ],
            },
            {
              label: "Capabilities and comparison",
              collapsed: true,
              items: [
                { label: "Understand capabilities", link: "/learn/capabilities-and-comparison/understand-capabilities" },
                { label: "Compare the features in Tiger Data products", link: "/learn/capabilities-and-comparison/feature-comparison" },
              ],
            },
            {
              label: "Data model",
              collapsed: true,
              items: [
                { label: "Design your data model", link: "/learn/data-model/design-your-data-model" },
                { label: "Wide, narrow, and medium tables", link: "/learn/data-model/wide-narrow-medium-tables" },
                {
                  label: "Primary keys, time columns, and uniqueness",
                  link: "/learn/data-model/primary-keys-time-and-uniqueness",
                },
                { label: "Schema optimization", link: "/learn/data-model/understand-database-schemas" },
              ],
            },
            {
              label: "Hypertables",
              collapsed: true,
              items: [
                { label: "Understand hypertables", link: "/learn/hypertables/understand-hypertables" },
                { label: "Create and configure a hypertable", link: "/learn/hypertables/creating-and-configuring-hypertables" },
                { label: "Partition a hypertable", link: "/learn/hypertables/partitioning-hypertables" },
                { label: "Hypertable indexes", link: "/learn/hypertables/hypertable-indexes" },
                { label: "Hypertable operations", link: "/learn/hypertables/optimize-data-in-hypertables" },
              ],
            },
            {
              label: "Hyperfunctions",
              collapsed: true,
              items: [
                { label: "About hyperfunctions", link: "/learn/hyperfunctions/about-hyperfunctions" },
              ],
            },
            {
              label: "Chunks and time buckets",
              collapsed: true,
              items: [
                { label: "Understand chunks", link: "/learn/chunks/understanding-chunks" },
                { label: "Size hypertable chunks", link: "/learn/hypertables/sizing-hypertable-chunks" },
                { label: "Understand time buckets", link: "/learn/data-lifecycle/time-buckets/about-time-buckets" },
                { label: "Use time buckets", link: "/learn/data-lifecycle/time-buckets/use-time-buckets" },
                { label: "Manually drop chunks", link: "/learn/data-lifecycle/data-retention/manually-drop-chunks" },
              ],
            },
            {
              label: "Hypercore",
              collapsed: true,
              items: [
                { label: "Understand hypercore", link: "/learn/columnar-storage/understand-hypercore" },
                { label: "Compression methods", link: "/learn/columnar-storage/compression-methods" },
              ],
            },
            {
              label: "Continuous aggregates (CAGGs)",
              collapsed: true,
              items: [
                { label: "Understand continuous aggregates", link: "/learn/continuous-aggregates" },
                { label: "Time and continuous aggregates", link: "/learn/continuous-aggregates/time-and-continuous-aggregates" },
                { label: "Hierarchical continuous aggregates", link: "/learn/continuous-aggregates/hierarchical-continuous-aggregates" },
                { label: "Real-time aggregates", link: "/learn/continuous-aggregates/real-time-aggregates" },
                { label: "Materialized hypertables", link: "/learn/continuous-aggregates/materialized-hypertables" },
              ],
            },
            {
              label: "Data lifecycle",
              collapsed: true,
              items: [
                { label: "Understand the data lifecycle", link: "/learn/data-lifecycle" },
                { label: "Hypertables and chunks", link: "/learn/hypertables/understand-hypertables" },
                { label: "Time buckets", link: "/learn/data-lifecycle/time-buckets/about-time-buckets" },
                { label: "Continuous aggregates", link: "/learn/continuous-aggregates" },
                { label: "Hypercore and the columnstore", link: "/learn/columnar-storage/understand-hypercore" },
                { label: "Tiered storage", link: "/learn/data-lifecycle/storage/about-storage-tiers" },
                { label: "Data retention", link: "/learn/data-lifecycle/data-retention/about-data-retention" },
              ],
            },
            {
              label: "Search",
              collapsed: true,
              items: [
                { label: "Key vector concepts for pgvector", link: "/learn/search/key-vector-database-concepts-for-understanding-pgvector" },
                { label: "Understand pg_textsearch and BM25 search", link: "/learn/search/using-pg-textsearch" },
                { label: "Understand pgvector and pgvectorscale", link: "/learn/search/pgvector-pgvectorsearch" },
              ],
            },
            {
              label: "Glossary",
              collapsed: true,
              items: [{ label: "Browse terms", link: "/learn/glossary" }],
            },
          ],
        },
        // Build tab — organized by Diataxis: hands-on learning first, then
        // job-scoped how-to groups, then optimization, then troubleshooting.
        {
          label: "Build",
          link: "/build",
          sidebar: [
            { label: "Overview", link: "/build" },
            // --- Tiger CLI and MCP: manage Tiger Cloud and drive the DB with agents ---
            {
              label: "Build with Tiger CLI and MCP",
              collapsed: true,
              items: [
                { label: "Common tasks", link: "/build/tiger-cli-mcp/common-tasks" },
                { label: "Best practices for AI agents", link: "/build/tiger-cli-mcp/agent-best-practices" },
                { label: "Cookbook", link: "/build/tiger-cli-mcp/cookbook" },
              ],
            },
            // --- Quickstarts ---
            {
              label: "Quickstarts",
              collapsed: true,
              items: [
                { label: "Overview", link: "/build/how-to" },
                { label: "Your first hypertable", link: "/build/how-to/your-first-hypertable" },
                { label: "Basic compression with hypercore", link: "/build/how-to/basic-compression" },
              ],
            },
            // --- Tutorials: combined tutorials, guided projects, and cookbook ---
            {
              label: "Tutorials",
              collapsed: true,
              items: [
                { label: "Overview", link: "/build/examples" },
                { label: "Create Tiger Cloud services with Terraform", link: "/build/examples/create-services-with-terraform" },
                { label: "Simulate an IoT sensor dataset", link: "/build/examples/simulate-iot-sensor-data" },
                { label: "Ingest real-time financial data", link: "/build/examples/ingest-real-time-financial-data" },
                { label: "Analyze application events with UUIDv7", link: "/build/examples/analyze-events-with-uuidv7" },
                { label: "Build hybrid search with BM25 and vectors", link: "/build/examples/hybrid-search" },
                { label: "Aggregate organizational data with AI agents", link: "/build/examples/aggregate-organizational-data-with-ai/" },
                { label: "Analyze stock market data", link: "/build/examples/analyze-stock-market-data" },
                { label: "Analyze NYC taxi data", link: "/build/examples/analyze-nyc-taxi-data" },
                { label: "Analyze Bitcoin blockchain", link: "/build/examples/analyze-blockchain" },
                { label: "Analyze energy consumption", link: "/build/examples/analyze-energy-consumption" },
                { label: "Visualize financial tick data with Grafana", link: "/build/examples/analyze-financial-tick-data" },
                { label: "Visualize transport and geospatial data with Grafana", link: "/build/examples/analyze-transport-data" },
                { label: "Tiger Data cookbook", link: "/build/examples/cookbook" },
              ],
            },
            // --- Data lifecycle how-tos (mirrors Learn > Data lifecycle) ---
            {
              label: "Data lifecycle",
              collapsed: true,
              items: [
                { label: "Your first hypertable", link: "/build/how-to/your-first-hypertable" },
                { label: "Set up hypercore", link: "/build/columnar-storage/setup-hypercore" },
                { label: "Create a continuous aggregate", link: "/build/continuous-aggregates/create-a-continuous-aggregate" },
                { label: "Manage storage and tiering", link: "/build/data-management/storage/manage-storage" },
                { label: "Create a retention policy", link: "/build/data-management/data-retention/create-a-retention-policy" },
                { label: "Create and manage custom jobs", link: "/build/data-management/create-and-manage-jobs" },
              ],
            },
            // --- Write and query data (split from "Manage my time-series data") ---
            {
              label: "Write and query data",
              collapsed: true,
              items: [
                { label: "Write and query data", link: "/build/data-management" },
                {
                  label: "Write data",
                  collapsed: true,
                  items: [
                    { label: "Insert data", link: "/build/data-management/write-data/insert" },
                    { label: "Update data", link: "/build/data-management/write-data/update" },
                    { label: "Upsert data", link: "/build/data-management/write-data/upsert" },
                    { label: "Delete data", link: "/build/data-management/write-data/delete" },
                  ],
                },
                {
                  label: "Query data",
                  collapsed: true,
                  items: [
                    { label: "SELECT data", link: "/build/data-management/query-data/select" },
                    { label: "Advanced analytic queries", link: "/build/data-management/query-data/advanced-analytic-queries" },
                    { label: "Query external data sources with FDW", link: "/build/performance-optimization/query-external-data-sources-with-fdw" },
                  ],
                },
                { label: "Run queries from Tiger Console", link: "/build/data-management/run-queries-from-tiger-console" },
              ],
            },
            // --- Automate with jobs and policies (split from "Manage my time-series data") ---
            {
              label: "Automate with jobs and policies",
              collapsed: true,
              items: [
                { label: "About automation", link: "/build/data-management/about-automation" },
                { label: "Add a data retention policy", link: "/build/data-management/data-retention/create-a-retention-policy" },
                { label: "Create and manage custom jobs", link: "/build/data-management/create-and-manage-jobs" },
                { label: "Create a custom retention job", link: "/build/data-management/example-generic-retention" },
                { label: "Custom job to downsample and compress chunks", link: "/build/data-management/example-downsample-and-compress" },
                { label: "Custom job for automatic tablespace management", link: "/build/data-management/example-tiered-storage" },
              ],
            },
            // --- Spread data across storage tiers (split from "Manage my time-series data") ---
            {
              label: "Spread data across storage tiers",
              collapsed: true,
              items: [
                { label: "Manage storage and tiering", link: "/build/data-management/storage/manage-storage" },
                { label: "Query tiered data", link: "/build/data-management/storage/query-tiered-data" },
                { label: "Replicas and forks with tiered data", link: "/build/data-management/storage/tiered-data-replicas-forks" },
              ],
            },
            // --- Use hyperfunctions for analytics (split from "Manage my time-series data") ---
            {
              label: "Use hyperfunctions for analytics",
              collapsed: true,
              items: [
                { label: "Hyperfunctions overview", link: "/build/data-management/hyperfunctions" },
                { label: "Counter aggregation", link: "/build/data-management/hyperfunctions/counter-aggregation" },
                { label: "Function pipelines", link: "/build/data-management/hyperfunctions/function-pipelines" },
                {
                  label: "Gapfilling and interpolation",
                  collapsed: true,
                  items: [
                    { label: "Gapfilling and interpolation", link: "/build/data-management/hyperfunctions/gapfilling-interpolation" },
                    { label: "Time bucket gapfill", link: "/build/data-management/hyperfunctions/gapfilling-interpolation/time-bucket-gapfill" },
                    { label: "Last observation carried forward", link: "/build/data-management/hyperfunctions/gapfilling-interpolation/locf" },
                  ],
                },
                { label: "Heartbeat aggregation", link: "/build/data-management/hyperfunctions/heartbeat-agg" },
                { label: "Hyperloglog", link: "/build/data-management/hyperfunctions/hyperloglog" },
                {
                  label: "Percentile approximation",
                  collapsed: true,
                  items: [
                    { label: "Percentile approximation", link: "/build/data-management/hyperfunctions/percentile-approx" },
                    { label: "Approximate percentiles", link: "/build/data-management/hyperfunctions/percentile-approx/approximate-percentile" },
                    { label: "Advanced aggregation methods", link: "/build/data-management/hyperfunctions/percentile-approx/advanced-agg" },
                  ],
                },
                { label: "Statistical aggregation", link: "/build/data-management/hyperfunctions/stats-aggs" },
                { label: "Time-weighted averages", link: "/build/data-management/hyperfunctions/time-weighted-averages" },
              ],
            },
            // --- Keep pre-computed aggregations up to date (CAGGs — unchanged) ---
            {
              label: "Keep pre-computed aggregations up to date",
              collapsed: true,
              items: [
                { label: "Create a continuous aggregate", link: "/build/continuous-aggregates/create-a-continuous-aggregate" },
                { label: "Refresh continuous aggregates", link: "/build/continuous-aggregates/refresh-policies" },
                { label: "Create an index on a continuous aggregate", link: "/build/continuous-aggregates/create-index" },
                { label: "Convert continuous aggregates to the columnstore", link: "/build/continuous-aggregates/compression-on-continuous-aggregates" },
                { label: "Drop data from continuous aggregates", link: "/build/continuous-aggregates/drop-data" },
                { label: "Migrate a continuous aggregate to the new form", link: "/build/continuous-aggregates/migrate-to-new-form" },
              ],
            },
            // --- Optimize storage and query speed (columnar storage) ---
            {
              label: "Optimize storage and query speed",
              collapsed: true,
              items: [
                { label: "Setup hypercore", link: "/build/columnar-storage/setup-hypercore" },
              ],
            },
            // --- Make queries and schemas faster (performance optimization) ---
            {
              label: "Make queries and schemas faster",
              collapsed: true,
              items: [
                { label: "Performance optimization", link: "/build/performance-optimization" },
                { label: "Accelerate queries using indexes", link: "/build/performance-optimization/indexing" },
                { label: "Get faster DISTINCT queries with SkipScan", link: "/build/performance-optimization/skipscan" },
                { label: "Automatically route queries to continuous aggregates", link: "/build/performance-optimization/cagg-query-rewrites" },
                { label: "Ensure data integrity with constraints", link: "/build/performance-optimization/ensure-data-integrity-with-constraints" },
                { label: "Alter and update table schemas", link: "/build/performance-optimization/alter-update-table-schema" },
                { label: "Handle semi-structured data with JSON", link: "/build/performance-optimization/handle-semi-structured-data-with-json" },
                { label: "Enforce constraints with unique indexes", link: "/build/performance-optimization/hypertables-and-unique-indexes" },
                { label: "Improve query and upsert performance", link: "/build/performance-optimization/secondary-indexes" },
                { label: "Improve hypertable performance", link: "/build/performance-optimization/improve-hypertable-performance" },
                { label: "Retrofit chunk intervals", link: "/build/performance-optimization/retrofit-chunk-intervals" },
                { label: "Improve storage performance using tablespaces", link: "/build/performance-optimization/manage-tablespaces" },
                { label: "Automate tasks with triggers", link: "/build/performance-optimization/automate-tasks-with-triggers" },
              ],
            },
            // --- Troubleshooting (renamed from "Tips and tricks") ---
            {
              label: "Troubleshooting",
              collapsed: true,
              items: [
                { label: "Common issues", link: "/build/tips-and-tricks" },
                { label: "Troubleshoot continuous aggregates", link: "/build/tips-and-tricks/troubleshoot-continuous-aggregates" },
                { label: "Troubleshoot hypertables", link: "/build/tips-and-tricks/troubleshoot-hypertables" },
                { label: "Troubleshoot hypercore", link: "/build/tips-and-tricks/troubleshoot-hypercore" },
                { label: "Troubleshoot import and ingest", link: "/build/tips-and-tricks/troubleshoot-import-ingest" },
                { label: "Troubleshoot queries", link: "/build/tips-and-tricks/troubleshoot-query-data" },
                { label: "Troubleshoot schema management", link: "/build/tips-and-tricks/troubleshoot-schema-management" },
                { label: "Troubleshoot time buckets", link: "/build/tips-and-tricks/troubleshoot-time-buckets" },
                { label: "Troubleshoot data retention", link: "/build/tips-and-tricks/troubleshoot-data-retention" },
                { label: "Troubleshoot data tiering", link: "/build/tips-and-tricks/troubleshoot-data-tiering" },
                { label: "Troubleshoot jobs", link: "/build/tips-and-tricks/troubleshoot-jobs" },
                { label: "Troubleshoot hyperfunctions", link: "/build/tips-and-tricks/troubleshoot-hyperfunctions" },
              ],
            },
          ],
        },
        // Migrate tab: data sync, file uploads, and full database migration
        {
          label: "Migrate",
          link: "/migrate",
          sidebar: [
            {
              label: "Overview",
              collapsed: true,
              items: [
                { label: "Overview", link: "/migrate" },
                { label: "Choose a migration approach", link: "/migrate/choose-your-approach" },
              ],
            },
            {
              label: "Migrate to Tiger Cloud",
              collapsed: false,
              items: [
                {
                  label: "Livesync replication",
                  collapsed: true,
                  items: [
                    { label: "Livesync replication", link: "/migrate/livesync-replication" },
                    { label: "Advanced topics", link: "/migrate/livesync-replication-advanced" },
                    { label: "Troubleshooting", link: "/migrate/livesync-replication-troubleshooting" },
                  ],
                },
                { label: "Migrate with downtime", link: "/migrate/migrate-with-downtime" },
                { label: "FAQ and troubleshooting", link: "/migrate/troubleshooting" },
                {
                  label: "Dual-write and backfill",
                  collapsed: true,
                  items: [
                    { label: "Dual-write and backfill", link: "/migrate/dual-write-and-backfill" },
                    { label: "From TimescaleDB", link: "/migrate/dual-write-and-backfill/dual-write-from-timescaledb" },
                    { label: "From PostgreSQL", link: "/migrate/dual-write-and-backfill/dual-write-from-postgres" },
                    { label: "From other databases", link: "/migrate/dual-write-and-backfill/dual-write-from-other" },
                    { label: "timescaledb-backfill tool", link: "/migrate/dual-write-and-backfill/timescaledb-backfill" },
                  ],
                },
              ],
            },
            {
              label: "Sync and stream",
              collapsed: false,
              items: [
                { label: "Sync from PostgreSQL", link: "/migrate/livesync-for-postgresql" },
                { label: "Sync from S3", link: "/migrate/livesync-for-s3" },
                { label: "Stream from Kafka", link: "/migrate/livesync-for-kafka" },
              ],
            },
            {
              label: "Upload files",
              collapsed: false,
              items: [
                { label: "Upload in Tiger Console", link: "/migrate/import-console" },
                { label: "Upload in the terminal", link: "/migrate/import-terminal" },
              ],
            },
          ],
        },
        // Integrate tab, mirrors the 5 filter dimensions in IntegrateOverview
        {
          label: "Integrate",
          link: "/integrate",
          sidebar: [
            { label: "Overview", link: "/integrate" },
            {
              label: "Connect to Tiger Data",
              collapsed: true,
              items: [{ label: "Connect to Tiger Data", link: "/integrate/find-connection-details" }],
            },
            // --- Type of Tool (matches integrationCategory) ---
            {
              label: "Type of tool",
              collapsed: false,
              items: [
                {
                  label: "Data engineering & ETL",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/data-engineering-etl" },
                    { label: "Amazon SageMaker", link: "/integrate/data-engineering-etl/amazon-sagemaker" },
                    { label: "Apache Airflow", link: "/integrate/data-engineering-etl/apache-airflow" },
                    { label: "AWS Lambda", link: "/integrate/data-engineering-etl/aws-lambda" },
                    { label: "Debezium", link: "/integrate/data-engineering-etl/debezium" },
                    { label: "Decodable", link: "/integrate/data-engineering-etl/decodable" },
                    { label: "Supabase", link: "/integrate/data-engineering-etl/supabase" },
                  ],
                },
                {
                  label: "Data ingestion & streaming",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/data-ingestion-streaming" },
                    { label: "Apache Kafka", link: "/integrate/data-ingestion-streaming/apache-kafka" },
                    { label: "EMQX", link: "/integrate/data-ingestion-streaming/emqx" },
                    { label: "Fivetran", link: "/integrate/data-ingestion-streaming/fivetran" },
                    { label: "HighByte", link: "/integrate/data-ingestion-streaming/highbyte" },
                    { label: "HiveMQ", link: "/integrate/data-ingestion-streaming/hivemq" },
                    { label: "Ignition", link: "/integrate/data-ingestion-streaming/ignition" },
                    { label: "Kepware KEPServerEX", link: "/integrate/data-ingestion-streaming/kepware-kepserverex" },
                    { label: "Litmus Edge", link: "/integrate/data-ingestion-streaming/litmus-edge" },
                    { label: "Node-RED", link: "/integrate/data-ingestion-streaming/node-red" },
                  ],
                },
                {
                  label: "BI & visualization",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/bi-vizualization" },
                    { label: "Power BI", link: "/integrate/bi-vizualization/power-bi" },
                    { label: "Tableau", link: "/integrate/bi-vizualization/tableau" },
                  ],
                },
                {
                  label: "Connectors",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/connectors" },
                    {
                      label: "Source",
                      collapsed: true,
                      items: [
                        { label: "Apache Kafka", link: "/integrate/connectors/source/sync-from-kafka" },
                        { label: "PostgreSQL", link: "/integrate/connectors/source/sync-from-postgres" },
                        { label: "Amazon S3", link: "/integrate/connectors/source/sync-from-s3" },
                      ],
                    },
                    {
                      label: "Destination",
                      collapsed: true,
                      items: [
                        {
                          label: "TigerLake (Iceberg)",
                          collapsed: true,
                          items: [
                            {
                              label: "Set up Iceberg connector",
                              link: "/integrate/connectors/destination/tigerlake",
                              attrs: { "data-no-flatten": "true" },
                            },
                            { label: "Query from Snowflake", link: "/integrate/connectors/destination/snowflake" },
                            { label: "Query with AWS Glue and Athena", link: "/integrate/connectors/destination/athena" },
                          ],
                        },
                      ],
                    },
                  ],
                },
                {
                  label: "Code & libraries",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/code" },
                    { label: "Connect your app", link: "/integrate/code/connect-your-app" },
                  ],
                },
                {
                  label: "Query & administration",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/query-administration" },
                    { label: "Azure Data Studio", link: "/integrate/query-administration/azure-data-studio" },
                    { label: "DBeaver", link: "/integrate/query-administration/dbeaver" },
                    { label: "pgAdmin", link: "/integrate/query-administration/pgadmin" },
                    { label: "PostgreSQL", link: "/integrate/query-administration/postgresql" },
                    { label: "psql", link: "/integrate/query-administration/psql" },
                    { label: "qStudio", link: "/integrate/query-administration/qstudio" },
                  ],
                },
                {
                  label: "Secure connectivity",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/secure-connectivity" },
                    { label: "Amazon Web Services", link: "/integrate/secure-connectivity/aws" },
                    { label: "Corporate data center", link: "/integrate/secure-connectivity/corporate-data-center" },
                    { label: "Google Cloud", link: "/integrate/secure-connectivity/google-cloud" },
                    { label: "Microsoft Azure", link: "/integrate/secure-connectivity/microsoft-azure" },
                  ],
                },
                {
                  label: "Observability & alerting",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/observability-alerting" },
                    { label: "Amazon CloudWatch", link: "/integrate/observability-alerting/cloudwatch" },
                    { label: "Azure Monitor", link: "/integrate/observability-alerting/azure-monitor" },
                    { label: "Datadog", link: "/integrate/observability-alerting/datadog" },
                    { label: "Grafana", link: "/integrate/observability-alerting/grafana" },
                    { label: "Prometheus", link: "/integrate/observability-alerting/prometheus" },
                    { label: "Telegraf", link: "/integrate/observability-alerting/telegraf" },
                    { label: "Exported metrics", link: "/integrate/observability-alerting/exported-metrics" },
                  ],
                },
                {
                  label: "Configuration & deployment",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/integrate/configuration-deployment" },
                    { label: "CloudNativePG", link: "/integrate/configuration-deployment/cloudnativepg" },
                    { label: "Kubernetes", link: "/integrate/configuration-deployment/kubernetes" },
                    { label: "Terraform", link: "/integrate/configuration-deployment/terraform" },
                  ],
                },
              ],
            },
            // --- Industry (matches integrationIndustry) ---
            {
              label: "Industry",
              collapsed: true,
              items: [
                { label: "Oil and gas", link: "/integrate/?industry=oil-and-gas" },
                { label: "IoT", link: "/integrate/?industry=iot" },
                { label: "Energy", link: "/integrate/?industry=energy" },
                { label: "Crypto", link: "/integrate/?industry=crypto" },
                { label: "Healthcare", link: "/integrate/?industry=healthcare" },
                { label: "Manufacturing", link: "/integrate/?industry=manufacturing" },
              ],
            },
            // --- Platform (matches integrationPlatforms) ---
            {
              label: "Platform",
              collapsed: true,
              items: [
                { label: "Tiger Cloud on AWS", link: "/integrate/?platform=aws" },
                { label: "Tiger Cloud on Azure", link: "/integrate/?platform=azure" },
                { label: "Self-Hosted", link: "/integrate/?platform=self-hosted" },
              ],
            },
            // --- First Party / Third Party ---
            {
              label: "First party/third party",
              collapsed: true,
              items: [
                { label: "First party", link: "/integrate/?party=first-party" },
                { label: "Third party", link: "/integrate/?party=third-party" },
              ],
            },
            // --- Technology ---
            {
              label: "Technology",
              collapsed: true,
              items: [
                { label: "PostgreSQL", link: "/integrate/?technology=PostgreSQL" },
                { label: "Python", link: "/integrate/?technology=Python" },
                { label: "SQL", link: "/integrate/?technology=SQL" },
                { label: "Kafka", link: "/integrate/?technology=Kafka" },
                { label: "AWS", link: "/integrate/?technology=AWS" },
                { label: "Azure", link: "/integrate/?technology=Azure" },
                { label: "GCP", link: "/integrate/?technology=GCP" },
                { label: "Terraform", link: "/integrate/?technology=Terraform" },
                { label: "Kubernetes", link: "/integrate/?technology=Kubernetes" },
                { label: "Grafana", link: "/integrate/?technology=Grafana" },
                { label: "Prometheus", link: "/integrate/?technology=Prometheus" },
                { label: "REST API", link: "/integrate/?technology=REST+API" },
              ],
            },
            {
              label: "Troubleshooting",
              collapsed: true,
              items: [{ label: "Troubleshooting", link: "/integrate/troubleshooting" }],
            },
          ],
        },
        // Deploy tab
        {
          label: "Deploy",
          link: "/deploy",
          sidebar: [
            { label: "Overview", link: "/deploy" },
            {
              label: "Tiger Cloud on AWS",
              collapsed: true,
              items: [
                    {
                      label: "Configuration",
                      collapsed: true,
                      items: [
                        { label: "About configuration", link: "/deploy/tiger-cloud/tiger-cloud-aws/configuration/about-configuration" },
                        { label: "Configure database parameters", link: "/deploy/tiger-cloud/tiger-cloud-aws/configuration/customize-configuration" },
                        { label: "Advanced parameters", link: "/deploy/tiger-cloud/tiger-cloud-aws/configuration/advanced-parameters" },
                      ],
                    },
                    {
                      label: "Service management",
                      collapsed: true,
                      items: [
                        { label: "About Tiger Cloud services", link: "/deploy/tiger-cloud/tiger-cloud-aws/service-management" },
                        { label: "Tiger Console overview", link: "/deploy/tiger-cloud/tiger-cloud-aws/service-management/service-overview" },
                        { label: "Service explorer", link: "/deploy/tiger-cloud/tiger-cloud-aws/service-management/service-explorer" },
                        { label: "Service management", link: "/deploy/tiger-cloud/tiger-cloud-aws/service-management/service-management" },
                        { label: "Manually change compute resources", link: "/deploy/tiger-cloud/tiger-cloud-aws/service-management/change-resources" },
                        { label: "Connection pooling", link: "/deploy/tiger-cloud/tiger-cloud-aws/service-management/connection-pooling" },
                        { label: "Fork services", link: "/deploy/tiger-cloud/tiger-cloud-aws/service-management/fork-services" },
                      ],
                    },
                    {
                      label: "High availability",
                      collapsed: true,
                      items: [
                        { label: "Overview", link: "/deploy/tiger-cloud/tiger-cloud-aws/high-availability/overview" },
                        { label: "Manage high availability", link: "/deploy/tiger-cloud/tiger-cloud-aws/high-availability/high-availability" },
                        { label: "Read scaling", link: "/deploy/tiger-cloud/tiger-cloud-aws/high-availability/read-scaling" },
                        { label: "Back up and recover services", link: "/deploy/tiger-cloud/tiger-cloud-aws/high-availability/backup-restore" },
                      ],
                    },
                    { label: "Monitor your services", link: "/deploy/tiger-cloud/tiger-cloud-aws/monitoring" },
                    {
                      label: "Security",
                      collapsed: true,
                      items: [
                        { label: "Overview", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/overview" },
                        { label: "Client credentials", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/client-credentials" },
                        { label: "IP allow list", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/ip-allow-list" },
                        { label: "Control user access to projects", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/members" },
                        { label: "Multi-factor authentication", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/multi-factor-authentication" },
                        { label: "Manage data security in your service", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/read-only-role" },
                        { label: "SAML authentication", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/saml" },
                        { label: "Connect with a stricter SSL mode", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/strict-ssl" },
                        { label: "VPC Peering", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/vpc" },
                        { label: "AWS Transit Gateway", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/transit-gateway" },
                        { label: "Private endpoints", link: "/deploy/tiger-cloud/tiger-cloud-aws/security/aws-privatelink" },
                      ],
                    },
                    {
                      label: "Extensions",
                      collapsed: true,
                      items: [
                        { label: "PostgreSQL extensions", link: "/deploy/tiger-cloud/tiger-cloud-aws/tiger-cloud-extensions" },
                        { label: "Optimize full text search with BM25", link: "/deploy/tiger-cloud/tiger-cloud-aws/tiger-cloud-extensions/pg-textsearch" },
                        { label: "Encrypt data using pgcrypto", link: "/deploy/tiger-cloud/tiger-cloud-aws/tiger-cloud-extensions/pgcrypto" },
                        { label: "Create a chatbot using pgvector", link: "/deploy/tiger-cloud/tiger-cloud-aws/tiger-cloud-extensions/pgvector" },
                        { label: "Analyse geospatial data with PostGIS", link: "/deploy/tiger-cloud/tiger-cloud-aws/tiger-cloud-extensions/postgis" },
                      ],
                    },
                    { label: "Maintenance and upgrades", link: "/deploy/tiger-cloud/tiger-cloud-aws/upgrades" },
                    { label: "Billing and account management", link: "/deploy/tiger-cloud/tiger-cloud-aws/pricing-and-account-management" },
                    { label: "Troubleshoot", link: "/deploy/tiger-cloud/troubleshoot" },
                    { label: "Vectorizer and LLM calls migration guide", link: "/deploy/tiger-cloud/vectorizer-deprecation" },
              ],
            },
            {
              label: "Tiger Cloud on Azure",
              collapsed: true,
              items: [
                    {
                      label: "Configuration",
                      collapsed: true,
                      items: [
                        { label: "About configuration", link: "/deploy/tiger-cloud/tiger-cloud-azure/configuration/about-configuration" },
                        { label: "Configure database parameters", link: "/deploy/tiger-cloud/tiger-cloud-azure/configuration/customize-configuration" },
                        { label: "Advanced parameters", link: "/deploy/tiger-cloud/tiger-cloud-azure/configuration/advanced-parameters" },
                      ],
                    },
                    {
                      label: "Service management",
                      collapsed: true,
                      items: [
                        { label: "About Tiger Cloud services", link: "/deploy/tiger-cloud/tiger-cloud-azure/service-management" },
                        { label: "Tiger Console overview", link: "/deploy/tiger-cloud/tiger-cloud-azure/service-management/service-overview" },
                        { label: "Service explorer", link: "/deploy/tiger-cloud/tiger-cloud-azure/service-management/service-explorer" },
                        { label: "Service management", link: "/deploy/tiger-cloud/tiger-cloud-azure/service-management/service-management" },
                        { label: "Manually change compute resources", link: "/deploy/tiger-cloud/tiger-cloud-azure/service-management/change-resources" },
                        { label: "Connection pooling", link: "/deploy/tiger-cloud/tiger-cloud-azure/service-management/connection-pooling" },
                        { label: "Fork services", link: "/deploy/tiger-cloud/tiger-cloud-azure/service-management/fork-services" },
                      ],
                    },
                    {
                      label: "High availability",
                      collapsed: true,
                      items: [
                        { label: "Overview", link: "/deploy/tiger-cloud/tiger-cloud-azure/high-availability/overview" },
                        { label: "Manage high availability", link: "/deploy/tiger-cloud/tiger-cloud-azure/high-availability/high-availability" },
                        { label: "Read scaling", link: "/deploy/tiger-cloud/tiger-cloud-azure/high-availability/read-scaling" },
                        { label: "Back up and recover services", link: "/deploy/tiger-cloud/tiger-cloud-azure/high-availability/backup-restore" },
                      ],
                    },
                    { label: "Monitor your services", link: "/deploy/tiger-cloud/tiger-cloud-azure/monitoring" },
                    {
                      label: "Security",
                      collapsed: true,
                      items: [
                        { label: "Overview", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/overview" },
                        { label: "Client credentials", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/client-credentials" },
                        { label: "IP allow list", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/ip-allow-list" },
                        { label: "Control user access to projects", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/members" },
                        { label: "Multi-factor authentication", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/multi-factor-authentication" },
                        { label: "Manage data security in your service", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/read-only-role" },
                        { label: "SAML authentication", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/saml" },
                        { label: "Connect with a stricter SSL mode", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/strict-ssl" },
                        { label: "Private endpoints", link: "/deploy/tiger-cloud/tiger-cloud-azure/security/azure-privatelink" },
                      ],
                    },
                    {
                      label: "Extensions",
                      collapsed: true,
                      items: [
                        { label: "PostgreSQL extensions", link: "/deploy/tiger-cloud/tiger-cloud-azure/tiger-cloud-extensions" },
                        { label: "Optimize full text search with BM25", link: "/deploy/tiger-cloud/tiger-cloud-azure/tiger-cloud-extensions/pg-textsearch" },
                        { label: "Encrypt data using pgcrypto", link: "/deploy/tiger-cloud/tiger-cloud-azure/tiger-cloud-extensions/pgcrypto" },
                        { label: "Create a chatbot using pgvector", link: "/deploy/tiger-cloud/tiger-cloud-azure/tiger-cloud-extensions/pgvector" },
                        { label: "Analyse geospatial data with PostGIS", link: "/deploy/tiger-cloud/tiger-cloud-azure/tiger-cloud-extensions/postgis" },
                      ],
                    },
                    { label: "Maintenance and upgrades", link: "/deploy/tiger-cloud/tiger-cloud-azure/upgrades" },
                    { label: "Billing and account management", link: "/deploy/tiger-cloud/tiger-cloud-azure/pricing-and-account-management" },
                    { label: "Troubleshoot", link: "/deploy/tiger-cloud/troubleshoot" },
                    { label: "Vectorizer and LLM calls migration guide", link: "/deploy/tiger-cloud/vectorizer-deprecation" },
              ],
            },
            {
              label: "Self-hosted TimescaleDB",
              collapsed: true,
              items: [
                { label: "Self-hosted TimescaleDB", link: "/deploy/self-hosted" },
                {
                  label: "Configuration",
                  collapsed: true,
                  items: [
                    { label: "Configuration guide", link: "/deploy/self-hosted/configuration" },
                    { label: "About configuration", link: "/deploy/self-hosted/configuration/about-configuration" },
                    { label: "Using timescaledb-tune", link: "/deploy/self-hosted/configuration/timescaledb-tune" },
                    { label: "Manual PostgreSQL configuration", link: "/deploy/self-hosted/configuration/postgres-config" },
                    { label: "TimescaleDB configuration", link: "/deploy/self-hosted/configuration/timescaledb-config" },
                    { label: "Docker configuration", link: "/deploy/self-hosted/configuration/docker-config" },
                    { label: "Telemetry", link: "/deploy/self-hosted/configuration/telemetry" },
                  ],
                },
                {
                  label: "Backup and restore",
                  collapsed: true,
                  items: [
                    { label: "Backup and restore", link: "/deploy/self-hosted/backup-and-restore" },
                    { label: "Logical backup", link: "/deploy/self-hosted/backup-and-restore/logical-backup" },
                    { label: "Physical backups", link: "/deploy/self-hosted/backup-and-restore/physical" },
                  ],
                },
                {
                  label: "Migrate to self-hosted TimescaleDB",
                  collapsed: true,
                  items: [
                    { label: "Migration guide", link: "/deploy/self-hosted/migration" },
                    { label: "Migrate entire database", link: "/deploy/self-hosted/migration/entire-database" },
                    { label: "Migrate schema then data", link: "/deploy/self-hosted/migration/schema-then-data" },
                    { label: "Migrate tables from the same database", link: "/deploy/self-hosted/migration/same-db" },
                    { label: "Migrate data from InfluxDB", link: "/deploy/self-hosted/migration/migrate-influxdb" },
                  ],
                },
                { label: "Manage storage using tablespaces", link: "/deploy/self-hosted/manage-storage" },
                {
                  label: "Replication and high availability",
                  collapsed: true,
                  items: [
                    { label: "Replication and HA", link: "/deploy/self-hosted/replication-and-ha" },
                    { label: "About high availability", link: "/deploy/self-hosted/replication-and-ha/about-ha" },
                    { label: "Configure replication", link: "/deploy/self-hosted/replication-and-ha/configure-replication" },
                  ],
                },
                {
                  label: "Additional tooling",
                  collapsed: true,
                  items: [
                    { label: "Available tools", link: "/deploy/self-hosted/tooling" },
                    { label: "TimescaleDB Tune", link: "/deploy/self-hosted/tooling/about-timescaledb-tune" },
                    { label: "Install and update TimescaleDB Toolkit", link: "/deploy/self-hosted/tooling/install-toolkit" },
                  ],
                },
                {
                  label: "Upgrade self-hosted TimescaleDB",
                  collapsed: true,
                  items: [
                    { label: "Upgrade guide", link: "/deploy/self-hosted/upgrades" },
                    { label: "Upgrade to a minor version", link: "/deploy/self-hosted/upgrades/minor-upgrade" },
                    { label: "Upgrade to a major version", link: "/deploy/self-hosted/upgrades/major-upgrade" },
                    { label: "Upgrade TimescaleDB in Docker", link: "/deploy/self-hosted/upgrades/upgrade-docker" },
                    { label: "Upgrade PostgreSQL", link: "/deploy/self-hosted/upgrades/upgrade-pg" },
                    { label: "Downgrade to a minor version", link: "/deploy/self-hosted/upgrades/downgrade" },
                  ],
                },
                { label: "Uninstall self-hosted TimescaleDB", link: "/deploy/self-hosted/uninstall" },
                { label: "Troubleshooting", link: "/deploy/self-hosted/troubleshooting" },
              ],
            },
            {
              label: "Managed Service for TimescaleDB",
              collapsed: true,
              items: [
                { label: "Managed Service for TimescaleDB", link: "/deploy/mst" },
                { label: "Create an MST service", link: "/deploy/mst/create-mst-service" },
                { label: "About MST", link: "/deploy/mst/about-mst" },
                { label: "Ingest data", link: "/deploy/mst/ingest-data" },
                { label: "User management", link: "/deploy/mst/user-management" },
                { label: "Billing", link: "/deploy/mst/billing" },
                { label: "Connection pools", link: "/deploy/mst/connection-pools" },
                { label: "Viewing service logs", link: "/deploy/mst/viewing-service-logs" },
                {
                  label: "VPC peering",
                  collapsed: true,
                  items: [
                    { label: "VPC peering", link: "/deploy/mst/vpc-peering" },
                    { label: "Configure VPC peering", link: "/deploy/mst/vpc-peering/vpc-peering" },
                    { label: "VPC peering on AWS", link: "/deploy/mst/vpc-peering/vpc-peering-aws" },
                    { label: "VPC peering on GCP", link: "/deploy/mst/vpc-peering/vpc-peering-gcp" },
                    { label: "VPC peering on Azure", link: "/deploy/mst/vpc-peering/vpc-peering-azure" },
                    { label: "AWS Transit Gateway", link: "/deploy/mst/vpc-peering/vpc-peering-aws-transit" },
                  ],
                },
                {
                  label: "Integrations",
                  collapsed: true,
                  items: [
                    { label: "MST integrations", link: "/deploy/mst/integrations" },
                    { label: "Google Data Studio", link: "/deploy/mst/integrations/google-data-studio-mst" },
                    { label: "Grafana", link: "/deploy/mst/integrations/grafana-mst" },
                    { label: "Logging", link: "/deploy/mst/integrations/logging" },
                    { label: "Datadog", link: "/deploy/mst/integrations/metrics-datadog" },
                    { label: "Prometheus", link: "/deploy/mst/integrations/prometheus-mst" },
                  ],
                },
                { label: "Supported extensions", link: "/deploy/mst/extensions" },
                { label: "Postgres dblink extension", link: "/deploy/mst/dblink-extension" },
                { label: "Security", link: "/deploy/mst/security" },
                { label: "PostgreSQL read replica", link: "/deploy/mst/postgresql-read-replica" },
                { label: "Maintenance", link: "/deploy/mst/maintenance" },
                { label: "Failover", link: "/deploy/mst/failover" },
                { label: "Backups", link: "/deploy/mst/manage-backups" },
                { label: "Aiven client", link: "/deploy/mst/aiven-client" },
                { label: "Migrate to MST", link: "/deploy/mst/migrate-to-mst" },
                { label: "REST API", link: "/deploy/mst/restapi" },
                { label: "Index issues", link: "/deploy/mst/identify-index-issues" },
                { label: "Troubleshooting", link: "/deploy/mst/troubleshooting" },
              ],
            },
            {
              label: "Limitations",
              collapsed: true,
              items: [{ label: "Limitations", link: "/deploy/limitations" }],
            },
          ],
        },
        // Reference tab
        {
          label: "Reference",
          link: "/reference",
          sidebar: [
            { label: "Overview", link: "/reference" },
            {
              label: "TimescaleDB",
              collapsed: true,
              items: [
                { label: "Overview", link: "/reference/timescaledb" },
                {
                  label: "Hypertables and chunks",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/hypertables" },
                    {
                      label: "Table creation",
                      collapsed: true,
                      items: [
                        { label: "CREATE TABLE", link: "/reference/timescaledb/hypertables/create_table" },
                        { label: "create_hypertable()", link: "/reference/timescaledb/hypertables/create_hypertable" },
                        { label: "CREATE INDEX (Transaction Per Chunk)", link: "/reference/timescaledb/hypertables/create_index" },
                        { label: "create_hypertable() (old interface)", link: "/reference/timescaledb/hypertables/create_hypertable_old" },
                      ],
                    },
                    {
                      label: "Chunk management",
                      collapsed: true,
                      items: [
                        { label: "create_chunk()", link: "/reference/timescaledb/hypertables/create_chunk" },
                        { label: "show_chunks()", link: "/reference/timescaledb/hypertables/show_chunks" },
                        { label: "drop_chunk()", link: "/reference/timescaledb/hypertables/drop_chunk" },
                        { label: "drop_chunks()", link: "/reference/timescaledb/hypertables/drop_chunks" },
                        { label: "move_chunk()", link: "/reference/timescaledb/hypertables/move_chunk" },
                        { label: "reorder_chunk()", link: "/reference/timescaledb/hypertables/reorder_chunk" },
                        { label: "merge_chunks()", link: "/reference/timescaledb/hypertables/merge_chunks" },
                        { label: "merge_chunks_concurrently()", link: "/reference/timescaledb/hypertables/merge_chunks_concurrently" },
                        { label: "split_chunk()", link: "/reference/timescaledb/hypertables/split_chunk" },
                        { label: "chunk_rewrite_cleanup()", link: "/reference/timescaledb/hypertables/chunk_rewrite_cleanup" },
                        { label: "attach_chunk()", link: "/reference/timescaledb/hypertables/attach_chunk" },
                        { label: "detach_chunk()", link: "/reference/timescaledb/hypertables/detach_chunk" },
                        { label: "set_chunk_time_interval()", link: "/reference/timescaledb/hypertables/set_chunk_time_interval" },
                        { label: "set_integer_now_func()", link: "/reference/timescaledb/hypertables/set_integer_now_func" },
                        { label: "add_dimension()", link: "/reference/timescaledb/hypertables/add_dimension" },
                        { label: "add_dimension() (deprecated)", link: "/reference/timescaledb/hypertables/add_dimension_old" },
                      ],
                    },
                    {
                      label: "Size and statistics",
                      collapsed: true,
                      items: [
                        { label: "hypertable_size()", link: "/reference/timescaledb/hypertables/hypertable_size" },
                        { label: "hypertable_detailed_size()", link: "/reference/timescaledb/hypertables/hypertable_detailed_size" },
                        { label: "hypertable_index_size()", link: "/reference/timescaledb/hypertables/hypertable_index_size" },
                        { label: "hypertable_approximate_size()", link: "/reference/timescaledb/hypertables/hypertable_approximate_size" },
                        { label: "hypertable_approximate_detailed_size()", link: "/reference/timescaledb/hypertables/hypertable_approximate_detailed_size" },
                        { label: "chunks_detailed_size()", link: "/reference/timescaledb/hypertables/chunks_detailed_size" },
                      ],
                    },
                    {
                      label: "Tablespace management",
                      collapsed: true,
                      items: [
                        { label: "attach_tablespace()", link: "/reference/timescaledb/hypertables/attach_tablespace" },
                        { label: "detach_tablespace()", link: "/reference/timescaledb/hypertables/detach_tablespace" },
                        { label: "detach_tablespaces()", link: "/reference/timescaledb/hypertables/detach_tablespaces" },
                        { label: "show_tablespaces()", link: "/reference/timescaledb/hypertables/show_tablespaces" },
                      ],
                    },
                    {
                      label: "Reordering and policies",
                      collapsed: true,
                      items: [
                        { label: "add_reorder_policy()", link: "/reference/timescaledb/hypertables/add_reorder_policy" },
                        { label: "remove_reorder_policy()", link: "/reference/timescaledb/hypertables/remove_reorder_policy" },
                      ],
                    },
                    {
                      label: "Query optimization",
                      collapsed: true,
                      items: [
                        { label: "enable_chunk_skipping()", link: "/reference/timescaledb/hypertables/enable_chunk_skipping" },
                        { label: "disable_chunk_skipping()", link: "/reference/timescaledb/hypertables/disable_chunk_skipping" },
                      ],
                    },
                  ],
                },
                {
                  label: "Hypercore",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/hypercore" },
                    {
                      label: "Policies",
                      collapsed: true,
                      items: [
                        { label: "add_columnstore_policy()", link: "/reference/timescaledb/hypercore/add_columnstore_policy" },
                        { label: "remove_columnstore_policy()", link: "/reference/timescaledb/hypercore/remove_columnstore_policy" },
                        { label: "add_compaction_policy()", link: "/reference/timescaledb/hypercore/add_compaction_policy" },
                        { label: "remove_compaction_policy()", link: "/reference/timescaledb/hypercore/remove_compaction_policy" },
                      ],
                    },
                    {
                      label: "Manual conversion",
                      collapsed: true,
                      items: [
                        { label: "ALTER TABLE (hypercore)", link: "/reference/timescaledb/hypercore/alter_table" },
                        { label: "convert_to_columnstore()", link: "/reference/timescaledb/hypercore/convert_to_columnstore" },
                        { label: "convert_to_rowstore()", link: "/reference/timescaledb/hypercore/convert_to_rowstore" },
                      ],
                    },
                    {
                      label: "Statistics and information",
                      collapsed: true,
                      items: [
                        { label: "chunk_columnstore_stats()", link: "/reference/timescaledb/hypercore/chunk_columnstore_stats" },
                        { label: "hypertable_columnstore_stats()", link: "/reference/timescaledb/hypercore/hypertable_columnstore_stats" },
                        { label: "chunk_columnstore_settings", link: "/reference/timescaledb/hypercore/chunk_columnstore_settings" },
                        { label: "hypertable_columnstore_settings", link: "/reference/timescaledb/hypercore/hypertable_columnstore_settings" },
                      ],
                    },
                  ],
                },
                {
                  label: "Continuous aggregates",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/continuous-aggregates" },
                    {
                      label: "Create and modify CAGGs",
                      collapsed: true,
                      items: [
                        { label: "CREATE MATERIALIZED VIEW", link: "/reference/timescaledb/continuous-aggregates/create_materialized_view" },
                        { label: "ALTER MATERIALIZED VIEW", link: "/reference/timescaledb/continuous-aggregates/alter_materialized_view" },
                        { label: "DROP MATERIALIZED VIEW", link: "/reference/timescaledb/continuous-aggregates/drop_materialized_view" },
                        { label: "cagg_migrate()", link: "/reference/timescaledb/continuous-aggregates/cagg_migrate" },
                        { label: "refresh_continuous_aggregate()", link: "/reference/timescaledb/continuous-aggregates/refresh_continuous_aggregate" },
                      ],
                    },
                    {
                      label: "Manage policies",
                      collapsed: true,
                      items: [
                        { label: "add_continuous_aggregate_policy()", link: "/reference/timescaledb/continuous-aggregates/add_continuous_aggregate_policy" },
                        { label: "remove_continuous_aggregate_policy()", link: "/reference/timescaledb/continuous-aggregates/remove_continuous_aggregate_policy" },
                      ],
                    },
                    {
                      label: "Experimental policy management",
                      collapsed: true,
                      items: [
                        { label: "add_policies()", link: "/reference/timescaledb/continuous-aggregates/add_policies" },
                        { label: "alter_policies()", link: "/reference/timescaledb/continuous-aggregates/alter_policies" },
                        { label: "remove_policies()", link: "/reference/timescaledb/continuous-aggregates/remove_policies" },
                        { label: "remove_all_policies()", link: "/reference/timescaledb/continuous-aggregates/remove_all_policies" },
                        { label: "show_policies()", link: "/reference/timescaledb/continuous-aggregates/show_policies" },
                      ],
                    },
                  ],
                },
                {
                  label: "Hyperfunctions",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/hyperfunctions" },
                    {
                      label: "Time series utilities",
                      collapsed: true,
                      items: [
                        { label: "days_in_month()", link: "/reference/timescaledb/hyperfunctions/time-series-utilities/days_in_month" },
                        { label: "first()", link: "/reference/timescaledb/hyperfunctions/time-series-utilities/first" },
                        { label: "last()", link: "/reference/timescaledb/hyperfunctions/time-series-utilities/last" },
                        { label: "month_normalize()", link: "/reference/timescaledb/hyperfunctions/time-series-utilities/month_normalize" },
                        { label: "time_bucket()", link: "/reference/timescaledb/hyperfunctions/time-series-utilities/time_bucket" },
                        { label: "to_epoch()", link: "/reference/timescaledb/hyperfunctions/time-series-utilities/to_epoch" },
                      ],
                    },
                    {
                      label: "Distribution analysis",
                      collapsed: true,
                      items: [
                        { label: "approximate_row_count()", link: "/reference/timescaledb/hyperfunctions/distribution-analysis/approximate_row_count" },
                        { label: "histogram()", link: "/reference/timescaledb/hyperfunctions/distribution-analysis/histogram" },
                      ],
                    },
                    {
                      label: "Gapfilling",
                      collapsed: true,
                      items: [
                        { label: "interpolate()", link: "/reference/timescaledb/hyperfunctions/time_bucket_gapfill/interpolate" },
                        { label: "locf()", link: "/reference/timescaledb/hyperfunctions/time_bucket_gapfill/locf" },
                        { label: "time_bucket_gapfill()", link: "/reference/timescaledb/hyperfunctions/time_bucket_gapfill/time_bucket_gapfill" },
                      ],
                    },
                  ],
                },
                {
                  label: "Data retention",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/data-retention" },
                    { label: "add_retention_policy()", link: "/reference/timescaledb/data-retention/add_retention_policy" },
                    { label: "remove_retention_policy()", link: "/reference/timescaledb/data-retention/remove_retention_policy" },
                  ],
                },
                {
                  label: "Jobs and automation",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/jobs-automation" },
                    { label: "add_job()", link: "/reference/timescaledb/jobs-automation/add_job" },
                    { label: "alter_job()", link: "/reference/timescaledb/jobs-automation/alter_job" },
                    { label: "delete_job()", link: "/reference/timescaledb/jobs-automation/delete_job" },
                    { label: "run_job()", link: "/reference/timescaledb/jobs-automation/run_job" },
                  ],
                },
                {
                  label: "UUIDv7 functions",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/uuid-functions" },
                    { label: "generate_uuidv7()", link: "/reference/timescaledb/uuid-functions/generate_uuidv7" },
                    { label: "to_uuidv7()", link: "/reference/timescaledb/uuid-functions/to_uuidv7" },
                    { label: "to_uuidv7_boundary()", link: "/reference/timescaledb/uuid-functions/to_uuidv7_boundary" },
                    { label: "uuid_timestamp()", link: "/reference/timescaledb/uuid-functions/uuid_timestamp" },
                    { label: "uuid_timestamp_micros()", link: "/reference/timescaledb/uuid-functions/uuid_timestamp_micros" },
                    { label: "uuid_version()", link: "/reference/timescaledb/uuid-functions/uuid_version" },
                  ],
                },
                {
                  label: "Informational views",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/informational-views" },
                    {
                      label: "Hypertable and chunk information",
                      collapsed: true,
                      items: [
                        { label: "timescaledb_information.chunks", link: "/reference/timescaledb/informational-views/chunks" },
                        { label: "timescaledb_information.dimensions", link: "/reference/timescaledb/informational-views/dimensions" },
                        { label: "timescaledb_information.hypertables", link: "/reference/timescaledb/informational-views/hypertables" },
                        { label: "timescaledb_information.continuous_aggregates", link: "/reference/timescaledb/informational-views/continuous_aggregates" },
                      ],
                    },
                    {
                      label: "Columnstore information",
                      collapsed: true,
                      items: [
                        { label: "chunk_columnstore_settings", link: "/reference/timescaledb/informational-views/chunk_columnstore_settings" },
                        { label: "hypertable_columnstore_settings", link: "/reference/timescaledb/informational-views/hypertable_columnstore_settings" },
                      ],
                    },
                    {
                      label: "Jobs and policies",
                      collapsed: true,
                      items: [
                        { label: "timescaledb_information.job_errors", link: "/reference/timescaledb/informational-views/job_errors" },
                        { label: "timescaledb_information.job_history", link: "/reference/timescaledb/informational-views/job_history" },
                        { label: "timescaledb_information.job_stats", link: "/reference/timescaledb/informational-views/job_stats" },
                        { label: "timescaledb_information.jobs", link: "/reference/timescaledb/informational-views/jobs" },
                        { label: "timescaledb_experimental.policies", link: "/reference/timescaledb/informational-views/policies" },
                      ],
                    },
                  ],
                },
                {
                  label: "Configuration",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/configuration" },
                    { label: "GUC parameters", link: "/reference/timescaledb/configuration/gucs" },
                    { label: "Configuration parameters", link: "/reference/timescaledb/configuration/tiger-postgres" },
                  ],
                },
                {
                  label: "Administration",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/timescaledb/administration" },
                    { label: "get_telemetry_report()", link: "/reference/timescaledb/administration/get_telemetry_report" },
                    { label: "timescaledb_post_restore()", link: "/reference/timescaledb/administration/timescaledb_post_restore" },
                    { label: "timescaledb_pre_restore()", link: "/reference/timescaledb/administration/timescaledb_pre_restore" },
                  ],
                },
                { label: "API reference tag overview", link: "/reference/timescaledb/tag-overview" },
              ],
            },
            {
              label: "TimescaleDB Toolkit",
              collapsed: true,
              items: [
                { label: "Overview", link: "/reference/toolkit" },
                {
                  label: "Approximate count distinct",
                  collapsed: true,
                  items: [
                    { label: "approx_count_distinct()", link: "/reference/toolkit/approximate-count-distinct/approx_count_distinct" },
                    { label: "distinct_count()", link: "/reference/toolkit/approximate-count-distinct/distinct_count" },
                    { label: "hyperloglog()", link: "/reference/toolkit/approximate-count-distinct/hyperloglog" },
                    { label: "rollup()", link: "/reference/toolkit/approximate-count-distinct/rollup" },
                    { label: "stderror()", link: "/reference/toolkit/approximate-count-distinct/stderror" },
                  ],
                },
                {
                  label: "Statistical and regression analysis",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/toolkit/statistical-and-regression-analysis" },
                    {
                      label: "One variable",
                      collapsed: true,
                      items: [
                        { label: "average()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/average" },
                        { label: "kurtosis()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/kurtosis" },
                        { label: "num_vals()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/num_vals" },
                        { label: "rolling()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/rolling" },
                        { label: "rollup()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/rollup" },
                        { label: "skewness()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/skewness" },
                        { label: "stats_agg() (one variable)", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/stats_agg" },
                        { label: "stddev()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/stddev" },
                        { label: "sum()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/sum" },
                        { label: "variance()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-one-variable/variance" },
                      ],
                    },
                    {
                      label: "Two variables",
                      collapsed: true,
                      items: [
                        { label: "average_y() | average_x()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/average_y_x" },
                        { label: "corr()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/corr" },
                        { label: "covariance()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/covariance" },
                        { label: "determination_coeff()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/determination_coeff" },
                        { label: "intercept()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/intercept" },
                        { label: "kurtosis_y() | kurtosis_x()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/kurtosis_y_x" },
                        { label: "num_vals()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/num_vals" },
                        { label: "rolling()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/rolling" },
                        { label: "rollup()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/rollup" },
                        { label: "skewness_y() | skewness_x()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/skewness_y_x" },
                        { label: "slope()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/slope" },
                        { label: "stats_agg() (two variables)", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/stats_agg" },
                        { label: "stddev_y() | stddev_x()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/stddev_y_x" },
                        { label: "sum_y() | sum_x()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/sum_y_x" },
                        { label: "variance_y() | variance_x()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/variance_y_x" },
                        { label: "x_intercept()", link: "/reference/toolkit/statistical-and-regression-analysis/stats_agg-two-variables/x_intercept" },
                      ],
                    },
                  ],
                },
                {
                  label: "Minimum and maximum",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/toolkit/minimum-and-maximum" },
                    {
                      label: "Minimum values",
                      collapsed: true,
                      items: [
                        { label: "into_array()", link: "/reference/toolkit/minimum-and-maximum/min_n/into_array" },
                        { label: "into_values()", link: "/reference/toolkit/minimum-and-maximum/min_n/into_values" },
                        { label: "min_n()", link: "/reference/toolkit/minimum-and-maximum/min_n/min_n" },
                        { label: "rollup()", link: "/reference/toolkit/minimum-and-maximum/min_n/rollup" },
                      ],
                    },
                    {
                      label: "Maximum values",
                      collapsed: true,
                      items: [
                        { label: "into_array()", link: "/reference/toolkit/minimum-and-maximum/max_n/into_array" },
                        { label: "into_values()", link: "/reference/toolkit/minimum-and-maximum/max_n/into_values" },
                        { label: "max_n()", link: "/reference/toolkit/minimum-and-maximum/max_n/max_n" },
                        { label: "rollup()", link: "/reference/toolkit/minimum-and-maximum/max_n/rollup" },
                      ],
                    },
                    {
                      label: "Minimum values by",
                      collapsed: true,
                      items: [
                        { label: "into_values()", link: "/reference/toolkit/minimum-and-maximum/min_n_by/into_values" },
                        { label: "min_n_by()", link: "/reference/toolkit/minimum-and-maximum/min_n_by/min_n_by" },
                        { label: "rollup()", link: "/reference/toolkit/minimum-and-maximum/min_n_by/rollup" },
                      ],
                    },
                    {
                      label: "Maximum values by",
                      collapsed: true,
                      items: [
                        { label: "into_values()", link: "/reference/toolkit/minimum-and-maximum/max_n_by/into_values" },
                        { label: "max_n_by()", link: "/reference/toolkit/minimum-and-maximum/max_n_by/max_n_by" },
                        { label: "rollup()", link: "/reference/toolkit/minimum-and-maximum/max_n_by/rollup" },
                      ],
                    },
                  ],
                },
                {
                  label: "Financial analysis",
                  collapsed: true,
                  items: [
                    { label: "candlestick()", link: "/reference/toolkit/candlestick_agg/candlestick" },
                    { label: "candlestick_agg()", link: "/reference/toolkit/candlestick_agg/candlestick_agg" },
                    { label: "close()", link: "/reference/toolkit/candlestick_agg/close" },
                    { label: "close_time()", link: "/reference/toolkit/candlestick_agg/close_time" },
                    { label: "high()", link: "/reference/toolkit/candlestick_agg/high" },
                    { label: "high_time()", link: "/reference/toolkit/candlestick_agg/high_time" },
                    { label: "low()", link: "/reference/toolkit/candlestick_agg/low" },
                    { label: "low_time()", link: "/reference/toolkit/candlestick_agg/low_time" },
                    { label: "open()", link: "/reference/toolkit/candlestick_agg/open" },
                    { label: "open_time()", link: "/reference/toolkit/candlestick_agg/open_time" },
                    { label: "rollup()", link: "/reference/toolkit/candlestick_agg/rollup" },
                    { label: "volume()", link: "/reference/toolkit/candlestick_agg/volume" },
                    { label: "vwap()", link: "/reference/toolkit/candlestick_agg/vwap" },
                  ],
                },
                {
                  label: "Percentile approximation",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/toolkit/percentile-approximation" },
                    {
                      label: "UddSketch",
                      collapsed: true,
                      items: [
                        { label: "approx_percentile()", link: "/reference/toolkit/percentile-approximation/uddsketch/approx_percentile" },
                        { label: "approx_percentile_array()", link: "/reference/toolkit/percentile-approximation/uddsketch/approx_percentile_array" },
                        { label: "approx_percentile_rank()", link: "/reference/toolkit/percentile-approximation/uddsketch/approx_percentile_rank" },
                        { label: "error()", link: "/reference/toolkit/percentile-approximation/uddsketch/error" },
                        { label: "mean()", link: "/reference/toolkit/percentile-approximation/uddsketch/mean" },
                        { label: "num_vals()", link: "/reference/toolkit/percentile-approximation/uddsketch/num_vals" },
                        { label: "percentile_agg()", link: "/reference/toolkit/percentile-approximation/uddsketch/percentile_agg" },
                        { label: "rollup()", link: "/reference/toolkit/percentile-approximation/uddsketch/rollup" },
                        { label: "total()", link: "/reference/toolkit/percentile-approximation/uddsketch/total" },
                        { label: "uddsketch()", link: "/reference/toolkit/percentile-approximation/uddsketch/uddsketch" },
                      ],
                    },
                    {
                      label: "t-digest",
                      collapsed: true,
                      items: [
                        { label: "approx_percentile()", link: "/reference/toolkit/percentile-approximation/tdigest/approx_percentile" },
                        { label: "approx_percentile_rank()", link: "/reference/toolkit/percentile-approximation/tdigest/approx_percentile_rank" },
                        { label: "max_val()", link: "/reference/toolkit/percentile-approximation/tdigest/max_val" },
                        { label: "mean()", link: "/reference/toolkit/percentile-approximation/tdigest/mean" },
                        { label: "min_val()", link: "/reference/toolkit/percentile-approximation/tdigest/min_val" },
                        { label: "num_vals()", link: "/reference/toolkit/percentile-approximation/tdigest/num_vals" },
                        { label: "rollup()", link: "/reference/toolkit/percentile-approximation/tdigest/rollup" },
                        { label: "tdigest()", link: "/reference/toolkit/percentile-approximation/tdigest/tdigest" },
                        { label: "total()", link: "/reference/toolkit/percentile-approximation/tdigest/total" },
                      ],
                    },
                  ],
                },
                {
                  label: "Counters and gauges",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/toolkit/counters-and-gauges" },
                    {
                      label: "Counter aggregation",
                      collapsed: true,
                      items: [
                        { label: "corr()", link: "/reference/toolkit/counters-and-gauges/counter_agg/corr" },
                        { label: "counter_agg()", link: "/reference/toolkit/counters-and-gauges/counter_agg/counter_agg" },
                        { label: "counter_zero_time()", link: "/reference/toolkit/counters-and-gauges/counter_agg/counter_zero_time" },
                        { label: "delta()", link: "/reference/toolkit/counters-and-gauges/counter_agg/delta" },
                        { label: "extrapolated_delta()", link: "/reference/toolkit/counters-and-gauges/counter_agg/extrapolated_delta" },
                        { label: "extrapolated_rate()", link: "/reference/toolkit/counters-and-gauges/counter_agg/extrapolated_rate" },
                        { label: "first_time()", link: "/reference/toolkit/counters-and-gauges/counter_agg/first_time" },
                        { label: "first_val()", link: "/reference/toolkit/counters-and-gauges/counter_agg/first_val" },
                        { label: "idelta_left()", link: "/reference/toolkit/counters-and-gauges/counter_agg/idelta_left" },
                        { label: "idelta_right()", link: "/reference/toolkit/counters-and-gauges/counter_agg/idelta_right" },
                        { label: "intercept()", link: "/reference/toolkit/counters-and-gauges/counter_agg/intercept" },
                        { label: "interpolated_delta()", link: "/reference/toolkit/counters-and-gauges/counter_agg/interpolated_delta" },
                        { label: "interpolated_rate()", link: "/reference/toolkit/counters-and-gauges/counter_agg/interpolated_rate" },
                        { label: "irate_left()", link: "/reference/toolkit/counters-and-gauges/counter_agg/irate_left" },
                        { label: "irate_right()", link: "/reference/toolkit/counters-and-gauges/counter_agg/irate_right" },
                        { label: "last_time()", link: "/reference/toolkit/counters-and-gauges/counter_agg/last_time" },
                        { label: "last_val()", link: "/reference/toolkit/counters-and-gauges/counter_agg/last_val" },
                        { label: "num_changes()", link: "/reference/toolkit/counters-and-gauges/counter_agg/num_changes" },
                        { label: "num_elements()", link: "/reference/toolkit/counters-and-gauges/counter_agg/num_elements" },
                        { label: "num_resets()", link: "/reference/toolkit/counters-and-gauges/counter_agg/num_resets" },
                        { label: "rate()", link: "/reference/toolkit/counters-and-gauges/counter_agg/rate" },
                        { label: "rollup()", link: "/reference/toolkit/counters-and-gauges/counter_agg/rollup" },
                        { label: "slope()", link: "/reference/toolkit/counters-and-gauges/counter_agg/slope" },
                        { label: "time_delta()", link: "/reference/toolkit/counters-and-gauges/counter_agg/time_delta" },
                        { label: "with_bounds()", link: "/reference/toolkit/counters-and-gauges/counter_agg/with_bounds" },
                      ],
                    },
                    {
                      label: "Gauge aggregation",
                      collapsed: true,
                      items: [
                        { label: "corr()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/corr" },
                        { label: "delta()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/delta" },
                        { label: "extrapolated_delta()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/extrapolated_delta" },
                        { label: "extrapolated_rate()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/extrapolated_rate" },
                        { label: "gauge_agg()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/gauge_agg" },
                        { label: "gauge_zero_time()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/gauge_zero_time" },
                        { label: "idelta_left()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/idelta_left" },
                        { label: "idelta_right()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/idelta_right" },
                        { label: "intercept()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/intercept" },
                        { label: "interpolated_delta()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/interpolated_delta" },
                        { label: "interpolated_rate()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/interpolated_rate" },
                        { label: "irate_left()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/irate_left" },
                        { label: "irate_right()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/irate_right" },
                        { label: "num_changes()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/num_changes" },
                        { label: "num_elements()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/num_elements" },
                        { label: "rate()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/rate" },
                        { label: "rollup()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/rollup" },
                        { label: "slope()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/slope" },
                        { label: "time_delta()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/time_delta" },
                        { label: "with_bounds()", link: "/reference/toolkit/counters-and-gauges/gauge_agg/with_bounds" },
                      ],
                    },
                  ],
                },
                {
                  label: "Time-weighted calculations",
                  collapsed: true,
                  items: [
                    { label: "average()", link: "/reference/toolkit/time_weight/average" },
                    { label: "first_time()", link: "/reference/toolkit/time_weight/first_time" },
                    { label: "first_val()", link: "/reference/toolkit/time_weight/first_val" },
                    { label: "integral()", link: "/reference/toolkit/time_weight/integral" },
                    { label: "interpolated_average()", link: "/reference/toolkit/time_weight/interpolated_average" },
                    { label: "interpolated_integral()", link: "/reference/toolkit/time_weight/interpolated_integral" },
                    { label: "last_time()", link: "/reference/toolkit/time_weight/last_time" },
                    { label: "last_val()", link: "/reference/toolkit/time_weight/last_val" },
                    { label: "rollup()", link: "/reference/toolkit/time_weight/rollup" },
                    { label: "time_weight()", link: "/reference/toolkit/time_weight/time_weight" },
                  ],
                },
                {
                  label: "Downsampling",
                  collapsed: true,
                  items: [
                    { label: "asap_smooth()", link: "/reference/toolkit/downsampling/asap_smooth" },
                    { label: "gp_lttb()", link: "/reference/toolkit/downsampling/gp_lttb" },
                    { label: "lttb()", link: "/reference/toolkit/downsampling/lttb" },
                  ],
                },
                {
                  label: "Timevector",
                  collapsed: true,
                  items: [
                    { label: "rollup()", link: "/reference/toolkit/timevector/rollup" },
                    { label: "timevector()", link: "/reference/toolkit/timevector/timevector" },
                    { label: "unnest()", link: "/reference/toolkit/timevector/unnest" },
                  ],
                },
                {
                  label: "Frequency analysis",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/toolkit/frequency-analysis" },
                    {
                      label: "Frequency aggregation",
                      collapsed: true,
                      items: [
                        { label: "freq_agg()", link: "/reference/toolkit/frequency-analysis/freq_agg/freq_agg" },
                        { label: "into_values()", link: "/reference/toolkit/frequency-analysis/freq_agg/into_values" },
                        { label: "max_frequency()", link: "/reference/toolkit/frequency-analysis/freq_agg/max_frequency" },
                        { label: "mcv_agg()", link: "/reference/toolkit/frequency-analysis/freq_agg/mcv_agg" },
                        { label: "min_frequency()", link: "/reference/toolkit/frequency-analysis/freq_agg/min_frequency" },
                        { label: "rollup()", link: "/reference/toolkit/frequency-analysis/freq_agg/rollup" },
                        { label: "topn()", link: "/reference/toolkit/frequency-analysis/freq_agg/topn" },
                      ],
                    },
                    {
                      label: "Count-min sketch",
                      collapsed: true,
                      items: [
                        { label: "approx_count()", link: "/reference/toolkit/frequency-analysis/count_min_sketch/approx_count" },
                        { label: "count_min_sketch()", link: "/reference/toolkit/frequency-analysis/count_min_sketch/count_min_sketch" },
                      ],
                    },
                  ],
                },
                {
                  label: "State tracking",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/toolkit/state-tracking" },
                    {
                      label: "Compact state aggregation",
                      collapsed: true,
                      items: [
                        { label: "compact_state_agg()", link: "/reference/toolkit/state-tracking/compact_state_agg/compact_state_agg" },
                        { label: "duration_in()", link: "/reference/toolkit/state-tracking/compact_state_agg/duration_in" },
                        { label: "interpolated_duration_in()", link: "/reference/toolkit/state-tracking/compact_state_agg/interpolated_duration_in" },
                        { label: "into_values()", link: "/reference/toolkit/state-tracking/compact_state_agg/into_values" },
                        { label: "rollup()", link: "/reference/toolkit/state-tracking/compact_state_agg/rollup" },
                      ],
                    },
                    {
                      label: "State aggregation",
                      collapsed: true,
                      items: [
                        { label: "duration_in()", link: "/reference/toolkit/state-tracking/state_agg/duration_in" },
                        { label: "interpolated_duration_in()", link: "/reference/toolkit/state-tracking/state_agg/interpolated_duration_in" },
                        { label: "interpolated_state_periods()", link: "/reference/toolkit/state-tracking/state_agg/interpolated_state_periods" },
                        { label: "interpolated_state_timeline()", link: "/reference/toolkit/state-tracking/state_agg/interpolated_state_timeline" },
                        { label: "into_values()", link: "/reference/toolkit/state-tracking/state_agg/into_values" },
                        { label: "rollup()", link: "/reference/toolkit/state-tracking/state_agg/rollup" },
                        { label: "state_agg()", link: "/reference/toolkit/state-tracking/state_agg/state_agg" },
                        { label: "state_at()", link: "/reference/toolkit/state-tracking/state_agg/state_at" },
                        { label: "state_periods()", link: "/reference/toolkit/state-tracking/state_agg/state_periods" },
                        { label: "state_timeline()", link: "/reference/toolkit/state-tracking/state_agg/state_timeline" },
                      ],
                    },
                    {
                      label: "Heartbeat aggregation",
                      collapsed: true,
                      items: [
                        { label: "dead_ranges()", link: "/reference/toolkit/state-tracking/heartbeat_agg/dead_ranges" },
                        { label: "downtime()", link: "/reference/toolkit/state-tracking/heartbeat_agg/downtime" },
                        { label: "heartbeat_agg()", link: "/reference/toolkit/state-tracking/heartbeat_agg/heartbeat_agg" },
                        { label: "interpolate()", link: "/reference/toolkit/state-tracking/heartbeat_agg/interpolate" },
                        { label: "interpolated_downtime()", link: "/reference/toolkit/state-tracking/heartbeat_agg/interpolated_downtime" },
                        { label: "interpolated_uptime()", link: "/reference/toolkit/state-tracking/heartbeat_agg/interpolated_uptime" },
                        { label: "live_at()", link: "/reference/toolkit/state-tracking/heartbeat_agg/live_at" },
                        { label: "live_ranges()", link: "/reference/toolkit/state-tracking/heartbeat_agg/live_ranges" },
                        { label: "num_gaps()", link: "/reference/toolkit/state-tracking/heartbeat_agg/num_gaps" },
                        { label: "num_live_ranges()", link: "/reference/toolkit/state-tracking/heartbeat_agg/num_live_ranges" },
                        { label: "rollup()", link: "/reference/toolkit/state-tracking/heartbeat_agg/rollup" },
                        { label: "trim_to()", link: "/reference/toolkit/state-tracking/heartbeat_agg/trim_to" },
                        { label: "uptime()", link: "/reference/toolkit/state-tracking/heartbeat_agg/uptime" },
                      ],
                    },
                  ],
                },
                {
                  label: "Saturating math",
                  collapsed: true,
                  items: [
                    { label: "saturating_add()", link: "/reference/toolkit/saturating-math/saturating_add" },
                    { label: "saturating_add_pos()", link: "/reference/toolkit/saturating-math/saturating_add_pos" },
                    { label: "saturating_mul()", link: "/reference/toolkit/saturating-math/saturating_mul" },
                    { label: "saturating_sub()", link: "/reference/toolkit/saturating-math/saturating_sub" },
                    { label: "saturating_sub_pos()", link: "/reference/toolkit/saturating-math/saturating_sub_pos" },
                  ],
                },
              ],
            },
            {
              label: "Tiger Cloud",
              collapsed: true,
              items: [
                { label: "Overview", link: "/reference/tiger-cloud" },
                { label: "Tiger CLI", link: "/reference/tiger-cloud/tiger-cli" },
                { label: "Tiger MCP", link: "/reference/tiger-cloud/tiger-mcp" },
                DOCS_LOCAL_WITHOUT_STAINLESS
                  ? {
                      label: "Tiger Cloud REST API",
                      collapsed: true,
                      items: [
                        {
                          label: "Local preview (generated API disabled)",
                          link: "/reference/tiger-cloud-rest-local-preview",
                        },
                      ],
                    }
                  : {
                      label: "Tiger Cloud REST API",
                      collapsed: true,
                      items: generateAPIReferenceItems({
                        excludeResourceOverviewPages: true,
                      }),
                    },
                {
                  label: "Data tiering",
                  collapsed: true,
                  items: [
                    { label: "Overview", link: "/reference/tiger-cloud/data-tiering" },
                    { label: "add_tiering_policy()", link: "/reference/tiger-cloud/data-tiering/add_tiering_policy" },
                    { label: "remove_tiering_policy()", link: "/reference/tiger-cloud/data-tiering/remove_tiering_policy" },
                    { label: "tier_chunk()", link: "/reference/tiger-cloud/data-tiering/tier_chunk" },
                    { label: "untier_chunk()", link: "/reference/tiger-cloud/data-tiering/untier_chunk" },
                    { label: "disable_tiering()", link: "/reference/tiger-cloud/data-tiering/disable_tiering" },
                  ],
                },
              ],
            },
          ],
        },
      ],
    }), ...(process.env.SENTRY_DSN
      ? [sentry({
          dsn: process.env.SENTRY_DSN,
        })]
      : [])],

    // WARNING: this `redirects` map does NOT take effect in the deployed production site.
    // The @stainless-api/docs integration unconditionally sets `build.redirects = false`
    // during `astro build` (see its astro:config:setup hook), which disables Astro's static
    // HTML redirect-page output. It writes the normalized map to dist/_stainless/redirects.json
    // instead, expecting the host to consume it — but nothing in this repo does, so every entry
    // here was silently a no-op in production. All page-move redirects now live in vercel.json
    // (the "new site / internal moves" block) instead. This block only still matters for
    // `pnpm dev` / `pnpm dev:local`, where Astro's dev server handles redirects natively and
    // Stainless's override doesn't apply (it only fires for the `build` command).
    redirects: withBase({
      ...(DOCS_LOCAL_WITHOUT_STAINLESS
        ? {
            "/reference/tiger-cloud-rest": "/reference/tiger-cloud-rest-local-preview",
          }
        : {}),
    }),
});