@shipeasy/openapi 1.0.0

package/dist/resources/index.d.ts

@@ -0,0 +1,2522 @@
+import { Transport } from '../transport.js';
+import '@shipeasy/core/pagination';
+import * as zod_v4_core from 'zod/v4/core';
+import * as zod from 'zod';
+import { KillswitchesClient } from './killswitches.js';
+export { killswitchesClient, killswitchesResource } from './killswitches.js';
+import { UniversesClient } from './universes.js';
+export { universesClient, universesResource } from './universes.js';
+import { ConfigsClient } from './configs.js';
+export { configsClient, configsResource } from './configs.js';
+import { ExperimentsClient } from './experiments.js';
+export { experimentsClient, experimentsResource } from './experiments.js';
+import { GatesClient } from './gates.js';
+export { gatesClient, gatesResource } from './gates.js';
+import '@shipeasy/core/schemas/gates';
+import '@shipeasy/core/schemas/universes';
+import '@shipeasy/core/schemas/killswitches';
+import '@shipeasy/core/schemas/configs';
+import '@shipeasy/core/schemas/experiments';
+
+/**
+ * Aggregate admin client. Each resource lives in its own file under
+ * ./resources/ — add a new entry here when you implement a new one.
+ *
+ * Both @shipeasy/cli and @shipeasy/mcp consume this client; do not duplicate
+ * endpoint paths or request shapes in the consumer packages.
+ */
+declare function createAdminClient(transport: Transport): {
+    transport: Transport;
+    gates: GatesClient;
+    experiments: ExperimentsClient;
+    configs: ConfigsClient;
+    universes: UniversesClient;
+    killswitches: KillswitchesClient;
+};
+type AdminClient = ReturnType<typeof createAdminClient>;
+/**
+ * Resource registry. MCP enumerates this to generate its tool catalog (one
+ * tool per CRUD verb + one per action). CLI can iterate it to auto-wire
+ * commander subcommands. Order is the surface order users see.
+ */
+declare const RESOURCE_REGISTRY: readonly [{
+    readonly name: "gates";
+    readonly basePath: "/api/admin/gates";
+    readonly describeOne: "feature gate";
+    readonly describeMany: "feature gates";
+    readonly tag: {
+        readonly name: "Gates";
+        readonly description: string;
+    };
+    readonly schemas: {
+        readonly create: zod.ZodObject<{
+            title: zod.ZodOptional<zod.ZodString>;
+            description: zod.ZodOptional<zod.ZodString>;
+            folder: zod.ZodOptional<zod.ZodString>;
+            group: zod.ZodOptional<zod.ZodString>;
+            owner_email: zod.ZodOptional<zod.ZodString>;
+            name: zod.ZodString;
+            enabled: zod.ZodDefault<zod.ZodBoolean>;
+            rollout_pct: zod.ZodDefault<zod.ZodNumber>;
+            rules: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+                attr: zod.ZodString;
+                op: zod.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: zod.ZodUnknown;
+            }, zod_v4_core.$strip>>>;
+            salt: zod.ZodOptional<zod.ZodString>;
+            stack: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"condition">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                pass: zod.ZodOptional<zod.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+                    attr: zod.ZodString;
+                    op: zod.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: zod.ZodUnknown;
+                }, zod_v4_core.$strip>>>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"rollout">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                rolloutPct: zod.ZodNumber;
+                bucketBy: zod.ZodOptional<zod.ZodString>;
+                salt: zod.ZodOptional<zod.ZodString>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>], "type">>>>;
+        }, zod_v4_core.$strip>;
+        readonly update: zod.ZodObject<{
+            title: zod.ZodOptional<zod.ZodString>;
+            description: zod.ZodOptional<zod.ZodString>;
+            folder: zod.ZodOptional<zod.ZodString>;
+            group: zod.ZodOptional<zod.ZodString>;
+            owner_email: zod.ZodOptional<zod.ZodString>;
+            rollout_pct: zod.ZodOptional<zod.ZodNumber>;
+            rules: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                attr: zod.ZodString;
+                op: zod.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: zod.ZodUnknown;
+            }, zod_v4_core.$strip>>>;
+            enabled: zod.ZodOptional<zod.ZodBoolean>;
+            stack: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"condition">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                pass: zod.ZodOptional<zod.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+                    attr: zod.ZodString;
+                    op: zod.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: zod.ZodUnknown;
+                }, zod_v4_core.$strip>>>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"rollout">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                rolloutPct: zod.ZodNumber;
+                bucketBy: zod.ZodOptional<zod.ZodString>;
+                salt: zod.ZodOptional<zod.ZodString>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>], "type">>>>;
+        }, zod_v4_core.$strip>;
+    };
+    readonly actions: readonly [{
+        readonly name: "enable";
+        readonly description: "Enable a gate";
+    }, {
+        readonly name: "disable";
+        readonly description: "Disable a gate";
+    }];
+    readonly endpoints: readonly [{
+        readonly operationId: "listGates";
+        readonly method: "GET";
+        readonly path: "";
+        readonly summary: "List feature gates";
+        readonly description: "Returns a single page of gates ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.";
+        readonly response: zod.ZodObject<{
+            data: zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                enabled: zod.ZodUnion<readonly [zod.ZodBoolean, zod.ZodNumber]>;
+                rolloutPct: zod.ZodNumber;
+                rules: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                    attr: zod.ZodString;
+                    op: zod.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: zod.ZodUnknown;
+                }, zod_v4_core.$strip>>>;
+                salt: zod.ZodOptional<zod.ZodString>;
+                title: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                description: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                folder: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                groupName: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                ownerEmail: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                stack: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                    id: zod.ZodString;
+                    type: zod.ZodLiteral<"condition">;
+                    name: zod.ZodOptional<zod.ZodString>;
+                    fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                    pass: zod.ZodOptional<zod.ZodEnum<{
+                        all: "all";
+                        any: "any";
+                    }>>;
+                    rules: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+                        attr: zod.ZodString;
+                        op: zod.ZodEnum<{
+                            eq: "eq";
+                            neq: "neq";
+                            in: "in";
+                            not_in: "not_in";
+                            gt: "gt";
+                            gte: "gte";
+                            lt: "lt";
+                            lte: "lte";
+                            contains: "contains";
+                            regex: "regex";
+                        }>;
+                        value: zod.ZodUnknown;
+                    }, zod_v4_core.$strip>>>;
+                    locked: zod.ZodOptional<zod.ZodBoolean>;
+                }, zod_v4_core.$strip>, zod.ZodObject<{
+                    id: zod.ZodString;
+                    type: zod.ZodLiteral<"rollout">;
+                    name: zod.ZodOptional<zod.ZodString>;
+                    fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                    rolloutPct: zod.ZodNumber;
+                    bucketBy: zod.ZodOptional<zod.ZodString>;
+                    salt: zod.ZodOptional<zod.ZodString>;
+                    locked: zod.ZodOptional<zod.ZodBoolean>;
+                }, zod_v4_core.$strip>], "type">>>>;
+                updatedAt: zod.ZodString;
+            }, zod_v4_core.$strip>>;
+            next_cursor: zod.ZodNullable<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly data: readonly [{
+                    readonly id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc";
+                    readonly name: "checkout_v2";
+                    readonly enabled: 1;
+                    readonly rolloutPct: 5000;
+                    readonly rules: readonly [{
+                        readonly attr: "country";
+                        readonly op: "in";
+                        readonly value: readonly ["US", "CA", "GB"];
+                    }, {
+                        readonly attr: "plan";
+                        readonly op: "neq";
+                        readonly value: "free";
+                    }];
+                    readonly salt: "9c1f4f1f2c0c4a5fa1c2b6d3e7c8e3a1";
+                    readonly title: "Checkout v2";
+                    readonly description: "New checkout flow. Pro users in US/CA/GB only.";
+                    readonly folder: "checkout";
+                    readonly groupName: "growth";
+                    readonly ownerEmail: "ana@example.com";
+                    readonly stack: null;
+                    readonly updatedAt: "2026-05-09T16:01:22.000Z";
+                }];
+                readonly next_cursor: null;
+            };
+        };
+        readonly useCase: "Snapshot every gate in the project — for example to render an admin overview or to drive a CI check that asserts no gate is left at 100% in staging.";
+    }, {
+        readonly operationId: "createGate";
+        readonly method: "POST";
+        readonly path: "";
+        readonly summary: "Create a feature gate";
+        readonly description: string;
+        readonly successStatus: 201;
+        readonly request: zod.ZodObject<{
+            title: zod.ZodOptional<zod.ZodString>;
+            description: zod.ZodOptional<zod.ZodString>;
+            folder: zod.ZodOptional<zod.ZodString>;
+            group: zod.ZodOptional<zod.ZodString>;
+            owner_email: zod.ZodOptional<zod.ZodString>;
+            name: zod.ZodString;
+            enabled: zod.ZodDefault<zod.ZodBoolean>;
+            rollout_pct: zod.ZodDefault<zod.ZodNumber>;
+            rules: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+                attr: zod.ZodString;
+                op: zod.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: zod.ZodUnknown;
+            }, zod_v4_core.$strip>>>;
+            salt: zod.ZodOptional<zod.ZodString>;
+            stack: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"condition">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                pass: zod.ZodOptional<zod.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+                    attr: zod.ZodString;
+                    op: zod.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: zod.ZodUnknown;
+                }, zod_v4_core.$strip>>>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"rollout">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                rolloutPct: zod.ZodNumber;
+                bucketBy: zod.ZodOptional<zod.ZodString>;
+                salt: zod.ZodOptional<zod.ZodString>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>], "type">>>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly minimal: {
+                    readonly summary: "Minimal — dark gate, name only";
+                    readonly description: "Smallest valid body. The gate is created `enabled: true` at `rollout_pct: 0`, with no rules. Ramp it later via PATCH.";
+                    readonly value: {
+                        readonly name: "checkout_v2";
+                    };
+                };
+                readonly targeted: {
+                    readonly summary: "Targeted rollout — rules + percentage";
+                    readonly description: "Gate Pro users in US/CA/GB, then hash 10% of that audience into the on-bucket (`rollout_pct: 1000` = 10.00%). Adds dashboard metadata so the gate is self-documenting.";
+                    readonly value: {
+                        readonly name: "checkout_v2";
+                        readonly rollout_pct: 1000;
+                        readonly rules: readonly [{
+                            readonly attr: "country";
+                            readonly op: "in";
+                            readonly value: readonly ["US", "CA", "GB"];
+                        }, {
+                            readonly attr: "plan";
+                            readonly op: "neq";
+                            readonly value: "free";
+                        }];
+                        readonly title: "Checkout v2";
+                        readonly description: "New checkout flow. Pro users in US/CA/GB only.";
+                        readonly folder: "checkout";
+                        readonly group: "growth";
+                        readonly owner_email: "ana@example.com";
+                    };
+                };
+                readonly gatekeeperStack: {
+                    readonly summary: "Gatekeeper stack — internal ∪ beta ∪ public";
+                    readonly description: "Three-layer fall-through: employees always on, opted-in beta accounts always on, then 25% of everyone else. First match wins; evaluation stops as soon as one entry returns `true`.";
+                    readonly value: {
+                        readonly name: "checkout_v2";
+                        readonly title: "Checkout v2";
+                        readonly owner_email: "ana@example.com";
+                        readonly stack: readonly [{
+                            readonly id: "01HKJ0EMP";
+                            readonly type: "condition";
+                            readonly name: "Employees";
+                            readonly pass: "any";
+                            readonly rules: readonly [{
+                                readonly attr: "email";
+                                readonly op: "regex";
+                                readonly value: "@acme\\.com$";
+                            }];
+                        }, {
+                            readonly id: "01HKJ0BETA";
+                            readonly type: "condition";
+                            readonly name: "Beta opt-in";
+                            readonly pass: "all";
+                            readonly rules: readonly [{
+                                readonly attr: "beta_opt_in";
+                                readonly op: "eq";
+                                readonly value: true;
+                            }];
+                        }, {
+                            readonly id: "01HKJ0PUB";
+                            readonly type: "rollout";
+                            readonly name: "Public";
+                            readonly rolloutPct: 2500;
+                            readonly bucketBy: "userID";
+                            readonly locked: true;
+                        }];
+                    };
+                };
+                readonly disabledOnCreate: {
+                    readonly summary: "Disabled on create — provision then enable later";
+                    readonly description: "Create with `enabled: false` so the gate evaluates to `false` for every caller until a follow-up `POST /{id}/enable`. Useful when provisioning ahead of a launch.";
+                    readonly value: {
+                        readonly name: "checkout_v2";
+                        readonly enabled: false;
+                        readonly rollout_pct: 0;
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc";
+                readonly name: "checkout_v2";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "updateGate";
+        readonly method: "PATCH";
+        readonly path: "/{id}";
+        readonly summary: "Update a feature gate";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque gate id (`gat_…`).";
+        };
+        readonly request: zod.ZodObject<{
+            title: zod.ZodOptional<zod.ZodString>;
+            description: zod.ZodOptional<zod.ZodString>;
+            folder: zod.ZodOptional<zod.ZodString>;
+            group: zod.ZodOptional<zod.ZodString>;
+            owner_email: zod.ZodOptional<zod.ZodString>;
+            rollout_pct: zod.ZodOptional<zod.ZodNumber>;
+            rules: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                attr: zod.ZodString;
+                op: zod.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: zod.ZodUnknown;
+            }, zod_v4_core.$strip>>>;
+            enabled: zod.ZodOptional<zod.ZodBoolean>;
+            stack: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"condition">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                pass: zod.ZodOptional<zod.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
+                    attr: zod.ZodString;
+                    op: zod.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: zod.ZodUnknown;
+                }, zod_v4_core.$strip>>>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                id: zod.ZodString;
+                type: zod.ZodLiteral<"rollout">;
+                name: zod.ZodOptional<zod.ZodString>;
+                fromTemplate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                rolloutPct: zod.ZodNumber;
+                bucketBy: zod.ZodOptional<zod.ZodString>;
+                salt: zod.ZodOptional<zod.ZodString>;
+                locked: zod.ZodOptional<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>], "type">>>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly rampRollout: {
+                    readonly summary: "Ramp rollout — 0 → 50%";
+                    readonly description: "Single-field patch. `5000` basis points = 50%.";
+                    readonly value: {
+                        readonly rollout_pct: 5000;
+                    };
+                };
+                readonly killSwitch: {
+                    readonly summary: "Kill switch — disable the gate";
+                    readonly description: "Forces evaluation to `false` for every caller, regardless of rules or rollout. Same effect as `POST /{id}/disable` but composable with other patches.";
+                    readonly value: {
+                        readonly enabled: false;
+                    };
+                };
+                readonly extendInRule: {
+                    readonly summary: "Add a value to an `in` rule";
+                    readonly description: "Array fields replace wholesale — there is no per-rule patch. To add `'AU'` to a country whitelist that previously held `['US','CA','GB']`, send the full new `rules` array. Same pattern applies to `not_in`.";
+                    readonly value: {
+                        readonly rules: readonly [{
+                            readonly attr: "country";
+                            readonly op: "in";
+                            readonly value: readonly ["US", "CA", "GB", "AU"];
+                        }, {
+                            readonly attr: "plan";
+                            readonly op: "neq";
+                            readonly value: "free";
+                        }];
+                    };
+                };
+                readonly replaceStack: {
+                    readonly summary: "Replace gatekeeper stack";
+                    readonly description: "Stack is replace-wholesale. Send the full new ordered list. Pass `\"stack\": null` to revert the gate to flat `rules` + `rollout_pct` evaluation.";
+                    readonly value: {
+                        readonly stack: readonly [{
+                            readonly id: "01HKJ0EMP";
+                            readonly type: "condition";
+                            readonly name: "Employees";
+                            readonly pass: "any";
+                            readonly rules: readonly [{
+                                readonly attr: "email";
+                                readonly op: "regex";
+                                readonly value: "@acme\\.com$";
+                            }];
+                        }, {
+                            readonly id: "01HKJ0PUB";
+                            readonly type: "rollout";
+                            readonly name: "Public";
+                            readonly rolloutPct: 5000;
+                            readonly locked: true;
+                        }];
+                    };
+                };
+                readonly updateMetadata: {
+                    readonly summary: "Update dashboard metadata";
+                    readonly description: "Any subset of `title`, `description`, `folder`, `group`, `owner_email`. Snake-case in the request; the GET response returns camelCase (`groupName`, `ownerEmail`).";
+                    readonly value: {
+                        readonly title: "Checkout v2 (50%)";
+                        readonly description: "Bumped to 50% after passing canary. Added AU.";
+                        readonly folder: "checkout";
+                        readonly owner_email: "ana@example.com";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "deleteGate";
+        readonly method: "DELETE";
+        readonly path: "/{id}";
+        readonly summary: "Delete a feature gate";
+        readonly description: "Soft-deletes the gate. Returns 409 if the gate is still referenced by a running experiment as a targeting gate — stop the experiment first.";
+        readonly pathParams: {
+            readonly id: "Stable opaque gate id (`gat_…`).";
+        };
+        readonly response: zod.ZodObject<{
+            ok: zod.ZodLiteral<true>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly ok: true;
+            };
+        };
+        readonly useCase: "Tear down a gate after a feature has fully shipped and the rollout flag is no longer needed.";
+    }, {
+        readonly operationId: "enableGate";
+        readonly method: "POST";
+        readonly path: "/{id}/enable";
+        readonly summary: "Enable a gate";
+        readonly description: "Sets `enabled: true`. The current `rollout_pct` is preserved.";
+        readonly pathParams: {
+            readonly id: "Stable opaque gate id.";
+        };
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            enabled: zod.ZodBoolean;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc";
+                readonly enabled: true;
+            };
+        };
+        readonly useCase: "Re-enable a previously disabled gate without re-issuing a full update.";
+    }, {
+        readonly operationId: "disableGate";
+        readonly method: "POST";
+        readonly path: "/{id}/disable";
+        readonly summary: "Disable a gate";
+        readonly description: "Sets `enabled: false` so the gate evaluates to `false` for every caller, regardless of `rollout_pct` or `rules`. Use as a quick kill switch.";
+        readonly pathParams: {
+            readonly id: "Stable opaque gate id.";
+        };
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            enabled: zod.ZodBoolean;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc";
+                readonly enabled: false;
+            };
+        };
+        readonly useCase: "Flip a gate off in production without redeploying — the canonical kill-switch flow.";
+    }];
+}, {
+    readonly name: "experiments";
+    readonly basePath: "/api/admin/experiments";
+    readonly describeOne: "experiment";
+    readonly describeMany: "experiments";
+    readonly tag: {
+        readonly name: "Experiments";
+        readonly description: string;
+    };
+    readonly schemas: {
+        readonly create: zod.ZodObject<{
+            name: zod.ZodString;
+            description: zod.ZodDefault<zod.ZodNullable<zod.ZodString>>;
+            tag: zod.ZodDefault<zod.ZodNullable<zod.ZodString>>;
+            universe: zod.ZodString;
+            targeting_gate: zod.ZodDefault<zod.ZodNullable<zod.ZodString>>;
+            allocation_pct: zod.ZodDefault<zod.ZodNumber>;
+            salt: zod.ZodOptional<zod.ZodString>;
+            params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodEnum<{
+                string: "string";
+                number: "number";
+                bool: "bool";
+            }>>>;
+            groups: zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+                weight: zod.ZodNumber;
+                params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>>;
+            significance_threshold: zod.ZodDefault<zod.ZodNumber>;
+            min_runtime_days: zod.ZodDefault<zod.ZodNumber>;
+            min_sample_size: zod.ZodDefault<zod.ZodNumber>;
+            sequential_testing: zod.ZodDefault<zod.ZodBoolean>;
+        }, zod_v4_core.$strip>;
+        readonly update: zod.ZodObject<{
+            name: zod.ZodOptional<zod.ZodString>;
+            description: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            tag: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            targeting_gate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            allocation_pct: zod.ZodOptional<zod.ZodNumber>;
+            salt: zod.ZodOptional<zod.ZodString>;
+            universe: zod.ZodOptional<zod.ZodString>;
+            params: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodEnum<{
+                string: "string";
+                number: "number";
+                bool: "bool";
+            }>>>;
+            groups: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+                weight: zod.ZodNumber;
+                params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>>>;
+            significance_threshold: zod.ZodOptional<zod.ZodNumber>;
+            min_runtime_days: zod.ZodOptional<zod.ZodNumber>;
+            min_sample_size: zod.ZodOptional<zod.ZodNumber>;
+            sequential_testing: zod.ZodOptional<zod.ZodBoolean>;
+        }, zod_v4_core.$strip>;
+    };
+    readonly actions: readonly [{
+        readonly name: "start";
+        readonly description: "Transition draft experiment to running";
+    }, {
+        readonly name: "stop";
+        readonly description: "Stop a running experiment";
+    }, {
+        readonly name: "archive";
+        readonly description: "Archive a stopped experiment";
+    }, {
+        readonly name: "reanalyze";
+        readonly description: "Re-run analysis pass for the experiment";
+    }];
+    readonly endpoints: readonly [{
+        readonly operationId: "listExperiments";
+        readonly method: "GET";
+        readonly path: "";
+        readonly summary: "List experiments";
+        readonly description: "Returns a single page of non-archived experiments ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.";
+        readonly response: zod.ZodObject<{
+            data: zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                description: zod.ZodNullable<zod.ZodString>;
+                tag: zod.ZodNullable<zod.ZodString>;
+                status: zod.ZodEnum<{
+                    draft: "draft";
+                    running: "running";
+                    stopped: "stopped";
+                    archived: "archived";
+                }>;
+                universe: zod.ZodString;
+                targetingGate: zod.ZodNullable<zod.ZodString>;
+                allocationPct: zod.ZodNumber;
+                salt: zod.ZodString;
+                params: zod.ZodRecord<zod.ZodString, zod.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    bool: "bool";
+                }>>;
+                groups: zod.ZodArray<zod.ZodObject<{
+                    name: zod.ZodString;
+                    weight: zod.ZodNumber;
+                    params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>;
+                significanceThreshold: zod.ZodNumber;
+                minRuntimeDays: zod.ZodNumber;
+                minSampleSize: zod.ZodNumber;
+                sequentialTesting: zod.ZodBoolean;
+                startedAt: zod.ZodNullable<zod.ZodString>;
+                stoppedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+                updatedAt: zod.ZodString;
+            }, zod_v4_core.$strip>>;
+            next_cursor: zod.ZodNullable<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly data: readonly [{
+                    id: string;
+                    name: string;
+                    description: string;
+                    tag: string;
+                    status: string;
+                    universe: string;
+                    targetingGate: null;
+                    allocationPct: number;
+                    salt: string;
+                    params: {
+                        cta_color: string;
+                    };
+                    groups: {
+                        name: string;
+                        weight: number;
+                        params: {
+                            cta_color: string;
+                        };
+                    }[];
+                    significanceThreshold: number;
+                    minRuntimeDays: number;
+                    minSampleSize: number;
+                    sequentialTesting: boolean;
+                    startedAt: string;
+                    stoppedAt: null;
+                    updatedAt: string;
+                }];
+                readonly next_cursor: null;
+            };
+        };
+        readonly useCase: "Snapshot every active experiment in the project — e.g. render an overview dashboard or drive a CI check that no experiment has been running past its `min_runtime_days`.";
+    }, {
+        readonly operationId: "getExperiment";
+        readonly method: "GET";
+        readonly path: "/{id}";
+        readonly summary: "Get one experiment";
+        readonly description: "Returns the full experiment row including groups, params, allocation, and lifecycle timestamps.";
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id (`exp_…`) or the experiment's `name`.";
+        };
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+            description: zod.ZodNullable<zod.ZodString>;
+            tag: zod.ZodNullable<zod.ZodString>;
+            status: zod.ZodEnum<{
+                draft: "draft";
+                running: "running";
+                stopped: "stopped";
+                archived: "archived";
+            }>;
+            universe: zod.ZodString;
+            targetingGate: zod.ZodNullable<zod.ZodString>;
+            allocationPct: zod.ZodNumber;
+            salt: zod.ZodString;
+            params: zod.ZodRecord<zod.ZodString, zod.ZodEnum<{
+                string: "string";
+                number: "number";
+                bool: "bool";
+            }>>;
+            groups: zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+                weight: zod.ZodNumber;
+                params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>>;
+            significanceThreshold: zod.ZodNumber;
+            minRuntimeDays: zod.ZodNumber;
+            minSampleSize: zod.ZodNumber;
+            sequentialTesting: zod.ZodBoolean;
+            startedAt: zod.ZodNullable<zod.ZodString>;
+            stoppedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            updatedAt: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                id: string;
+                name: string;
+                description: string;
+                tag: string;
+                status: string;
+                universe: string;
+                targetingGate: null;
+                allocationPct: number;
+                salt: string;
+                params: {
+                    cta_color: string;
+                };
+                groups: {
+                    name: string;
+                    weight: number;
+                    params: {
+                        cta_color: string;
+                    };
+                }[];
+                significanceThreshold: number;
+                minRuntimeDays: number;
+                minSampleSize: number;
+                sequentialTesting: boolean;
+                startedAt: string;
+                stoppedAt: null;
+                updatedAt: string;
+            };
+        };
+        readonly useCase: "Fetch one experiment to render the detail page or to inspect its current allocation and group weights.";
+    }, {
+        readonly operationId: "createExperiment";
+        readonly method: "POST";
+        readonly path: "";
+        readonly summary: "Create an experiment";
+        readonly description: string;
+        readonly successStatus: 201;
+        readonly request: zod.ZodObject<{
+            name: zod.ZodString;
+            description: zod.ZodDefault<zod.ZodNullable<zod.ZodString>>;
+            tag: zod.ZodDefault<zod.ZodNullable<zod.ZodString>>;
+            universe: zod.ZodString;
+            targeting_gate: zod.ZodDefault<zod.ZodNullable<zod.ZodString>>;
+            allocation_pct: zod.ZodDefault<zod.ZodNumber>;
+            salt: zod.ZodOptional<zod.ZodString>;
+            params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodEnum<{
+                string: "string";
+                number: "number";
+                bool: "bool";
+            }>>>;
+            groups: zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+                weight: zod.ZodNumber;
+                params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>>;
+            significance_threshold: zod.ZodDefault<zod.ZodNumber>;
+            min_runtime_days: zod.ZodDefault<zod.ZodNumber>;
+            min_sample_size: zod.ZodDefault<zod.ZodNumber>;
+            sequential_testing: zod.ZodDefault<zod.ZodBoolean>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly minimal: {
+                    readonly summary: "Minimal — two-group 50/50";
+                    readonly description: "Smallest valid body. Two groups at 50/50, no allocation, no targeting.";
+                    readonly value: {
+                        readonly name: "checkout_button_color";
+                        readonly universe: "primary_users";
+                        readonly groups: readonly [{
+                            readonly name: "control";
+                            readonly weight: 5000;
+                        }, {
+                            readonly name: "treatment";
+                            readonly weight: 5000;
+                        }];
+                    };
+                };
+                readonly targeted: {
+                    readonly summary: "Targeted — gate + allocation + params";
+                    readonly description: "Gate the audience with a `targeting_gate`, allocate 50% of it, and parameterise the variants.";
+                    readonly value: {
+                        readonly name: "checkout_button_color";
+                        readonly description: "Green CTA on checkout for Pro users.";
+                        readonly universe: "primary_users";
+                        readonly targeting_gate: "pro_plan_only";
+                        readonly allocation_pct: 5000;
+                        readonly params: {
+                            readonly cta_color: "string";
+                        };
+                        readonly groups: readonly [{
+                            readonly name: "control";
+                            readonly weight: 5000;
+                            readonly params: {
+                                readonly cta_color: "blue";
+                            };
+                        }, {
+                            readonly name: "treatment";
+                            readonly weight: 5000;
+                            readonly params: {
+                                readonly cta_color: "green";
+                            };
+                        }];
+                    };
+                };
+                readonly multivariant: {
+                    readonly summary: "Multivariant — three groups";
+                    readonly description: "Three variants splitting 40/30/30. Requires the sum to equal 10000.";
+                    readonly value: {
+                        readonly name: "headline_test";
+                        readonly universe: "primary_users";
+                        readonly groups: readonly [{
+                            readonly name: "control";
+                            readonly weight: 4000;
+                        }, {
+                            readonly name: "alt_a";
+                            readonly weight: 3000;
+                        }, {
+                            readonly name: "alt_b";
+                            readonly weight: 3000;
+                        }];
+                    };
+                };
+                readonly sequential: {
+                    readonly summary: "Sequential testing — Premium plan";
+                    readonly description: "Enable always-valid sequential tests. Requires Premium plan or higher.";
+                    readonly value: {
+                        readonly name: "checkout_button_color";
+                        readonly universe: "primary_users";
+                        readonly groups: readonly [{
+                            readonly name: "control";
+                            readonly weight: 5000;
+                        }, {
+                            readonly name: "treatment";
+                            readonly weight: 5000;
+                        }];
+                        readonly sequential_testing: true;
+                        readonly min_runtime_days: 14;
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
+                readonly name: "checkout_button_color";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "updateExperiment";
+        readonly method: "PATCH";
+        readonly path: "/{id}";
+        readonly summary: "Update an experiment";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id.";
+        };
+        readonly request: zod.ZodObject<{
+            name: zod.ZodOptional<zod.ZodString>;
+            description: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            tag: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            targeting_gate: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            allocation_pct: zod.ZodOptional<zod.ZodNumber>;
+            salt: zod.ZodOptional<zod.ZodString>;
+            universe: zod.ZodOptional<zod.ZodString>;
+            params: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodEnum<{
+                string: "string";
+                number: "number";
+                bool: "bool";
+            }>>>;
+            groups: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+                name: zod.ZodString;
+                weight: zod.ZodNumber;
+                params: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>>>;
+            significance_threshold: zod.ZodOptional<zod.ZodNumber>;
+            min_runtime_days: zod.ZodOptional<zod.ZodNumber>;
+            min_sample_size: zod.ZodOptional<zod.ZodNumber>;
+            sequential_testing: zod.ZodOptional<zod.ZodBoolean>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly rampAllocation: {
+                    readonly summary: "Ramp allocation — 0 → 50%";
+                    readonly description: "Bumps the share of the targeted audience enrolled. Allowed only when the experiment is in `draft`.";
+                    readonly value: {
+                        readonly allocation_pct: 5000;
+                    };
+                };
+                readonly changeWeights: {
+                    readonly summary: "Change group weights";
+                    readonly description: "Replace the groups array — weights must still sum to 10000.";
+                    readonly value: {
+                        readonly groups: readonly [{
+                            readonly name: "control";
+                            readonly weight: 2500;
+                        }, {
+                            readonly name: "treatment";
+                            readonly weight: 7500;
+                        }];
+                    };
+                };
+                readonly tighterSignificance: {
+                    readonly summary: "Tighter significance threshold";
+                    readonly description: "Drop the p-value cutoff from 0.05 → 0.01. Requires Pro plan or higher.";
+                    readonly value: {
+                        readonly significance_threshold: 0.01;
+                    };
+                };
+                readonly updateMetadata: {
+                    readonly summary: "Update metadata";
+                    readonly description: "Change description/tag/targeting_gate freely on running experiments.";
+                    readonly value: {
+                        readonly description: "Bumped to 50% after passing canary on 25%.";
+                        readonly tag: "checkout";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "deleteExperiment";
+        readonly method: "DELETE";
+        readonly path: "/{id}";
+        readonly summary: "Delete an experiment";
+        readonly description: "Archives the experiment (soft-delete via status transition). Returns `409` if the experiment is still `running` — stop it first.";
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id.";
+        };
+        readonly response: zod.ZodObject<{
+            ok: zod.ZodLiteral<true>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly ok: true;
+            };
+        };
+        readonly useCase: "Tear down an experiment after the analysis is signed off.";
+    }, {
+        readonly operationId: "setExperimentStatus";
+        readonly method: "POST";
+        readonly path: "/{id}/status";
+        readonly summary: "Transition experiment status";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id.";
+        };
+        readonly request: zod.ZodObject<{
+            status: zod.ZodEnum<{
+                draft: "draft";
+                running: "running";
+                stopped: "stopped";
+                archived: "archived";
+            }>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            status: zod.ZodEnum<{
+                draft: "draft";
+                running: "running";
+                stopped: "stopped";
+                archived: "archived";
+            }>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly start: {
+                    readonly summary: "Start — draft → running";
+                    readonly description: "Begins allocation. The experiment counts against the plan's `experiments_running` limit.";
+                    readonly value: {
+                        readonly status: "running";
+                    };
+                };
+                readonly stop: {
+                    readonly summary: "Stop — running → stopped";
+                    readonly description: "Halts allocation. Existing exposures remain analysable.";
+                    readonly value: {
+                        readonly status: "stopped";
+                    };
+                };
+                readonly archive: {
+                    readonly summary: "Archive — stopped → archived";
+                    readonly description: "Soft-deletes the experiment. List endpoints exclude archived rows by default.";
+                    readonly value: {
+                        readonly status: "archived";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
+                readonly status: "running";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "setExperimentMetrics";
+        readonly method: "POST";
+        readonly path: "/{id}/metrics";
+        readonly summary: "Attach metrics";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id.";
+        };
+        readonly request: zod.ZodObject<{
+            metrics: zod.ZodArray<zod.ZodObject<{
+                metric_id: zod.ZodString;
+                role: zod.ZodEnum<{
+                    goal: "goal";
+                    guardrail: "guardrail";
+                    secondary: "secondary";
+                }>;
+            }, zod_v4_core.$strip>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            metrics: zod.ZodArray<zod.ZodObject<{
+                metric_id: zod.ZodString;
+                role: zod.ZodEnum<{
+                    goal: "goal";
+                    guardrail: "guardrail";
+                    secondary: "secondary";
+                }>;
+            }, zod_v4_core.$strip>>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly standard: {
+                    readonly summary: "Standard — one goal + one guardrail";
+                    readonly description: "Attaches one decision metric and one safety metric.";
+                    readonly value: {
+                        readonly metrics: readonly [{
+                            readonly metric_id: "met_checkout_completed";
+                            readonly role: "goal";
+                        }, {
+                            readonly metric_id: "met_page_errors";
+                            readonly role: "guardrail";
+                        }];
+                    };
+                };
+                readonly detach: {
+                    readonly summary: "Detach all";
+                    readonly description: "Send an empty array to clear every metric.";
+                    readonly value: {
+                        readonly metrics: readonly [];
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
+                readonly metrics: readonly [{
+                    readonly metric_id: "met_checkout_completed";
+                    readonly role: "goal";
+                }, {
+                    readonly metric_id: "met_page_errors";
+                    readonly role: "guardrail";
+                }];
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "getExperimentResults";
+        readonly method: "GET";
+        readonly path: "/{id}/results";
+        readonly summary: "Get analysis results";
+        readonly description: "Returns the latest analysis output for the experiment — one row per metric/group/day, including sample size, mean, % delta vs. control, p-value, and a sample-ratio mismatch flag.";
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id.";
+        };
+        readonly response: zod.ZodObject<{
+            experiment: zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                status: zod.ZodEnum<{
+                    draft: "draft";
+                    running: "running";
+                    stopped: "stopped";
+                    archived: "archived";
+                }>;
+            }, zod_v4_core.$strip>;
+            results: zod.ZodArray<zod.ZodObject<{
+                metric: zod.ZodString;
+                group_name: zod.ZodString;
+                ds: zod.ZodString;
+                n: zod.ZodNullable<zod.ZodNumber>;
+                mean: zod.ZodNullable<zod.ZodNumber>;
+                delta_pct: zod.ZodNullable<zod.ZodNumber>;
+                p_value: zod.ZodNullable<zod.ZodNumber>;
+                srm_detected: zod.ZodNullable<zod.ZodNumber>;
+            }, zod_v4_core.$strip>>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly experiment: {
+                    readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
+                    readonly name: "checkout_button_color";
+                    readonly status: "running";
+                };
+                readonly results: readonly [{
+                    readonly metric: "checkout_completed";
+                    readonly group_name: "control";
+                    readonly ds: "2026-05-09";
+                    readonly n: 12421;
+                    readonly mean: 0.1834;
+                    readonly delta_pct: null;
+                    readonly p_value: null;
+                    readonly srm_detected: 0;
+                }, {
+                    readonly metric: "checkout_completed";
+                    readonly group_name: "treatment";
+                    readonly ds: "2026-05-09";
+                    readonly n: 12519;
+                    readonly mean: 0.1922;
+                    readonly delta_pct: 4.8;
+                    readonly p_value: 0.018;
+                    readonly srm_detected: 0;
+                }];
+            };
+        };
+        readonly useCase: "Render the results table on the experiment detail page or drive an automated decision once a `goal` metric reaches significance.";
+    }, {
+        readonly operationId: "getExperimentTimeseries";
+        readonly method: "GET";
+        readonly path: "/{id}/timeseries";
+        readonly summary: "Get analysis timeseries";
+        readonly description: "Same row shape as `/results`, but returns every daily slice rather than the latest. Filter to a single metric with the `metric` query parameter.";
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id.";
+        };
+        readonly queryParams: {
+            readonly metric: {
+                readonly schema: zod.ZodOptional<zod.ZodString>;
+                readonly description: "Optional metric name to filter the series.";
+            };
+        };
+        readonly response: zod.ZodObject<{
+            experiment: zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                status: zod.ZodEnum<{
+                    draft: "draft";
+                    running: "running";
+                    stopped: "stopped";
+                    archived: "archived";
+                }>;
+            }, zod_v4_core.$strip>;
+            series: zod.ZodArray<zod.ZodObject<{
+                metric: zod.ZodString;
+                group_name: zod.ZodString;
+                ds: zod.ZodString;
+                n: zod.ZodNullable<zod.ZodNumber>;
+                mean: zod.ZodNullable<zod.ZodNumber>;
+                delta_pct: zod.ZodNullable<zod.ZodNumber>;
+                p_value: zod.ZodNullable<zod.ZodNumber>;
+                srm_detected: zod.ZodNullable<zod.ZodNumber>;
+            }, zod_v4_core.$strip>>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly experiment: {
+                    readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
+                    readonly name: "checkout_button_color";
+                    readonly status: "running";
+                };
+                readonly series: readonly [{
+                    readonly metric: "checkout_completed";
+                    readonly group_name: "treatment";
+                    readonly ds: "2026-05-08";
+                    readonly n: 11200;
+                    readonly mean: 0.1903;
+                    readonly delta_pct: 3.9;
+                    readonly p_value: 0.034;
+                    readonly srm_detected: 0;
+                }, {
+                    readonly metric: "checkout_completed";
+                    readonly group_name: "treatment";
+                    readonly ds: "2026-05-09";
+                    readonly n: 12519;
+                    readonly mean: 0.1922;
+                    readonly delta_pct: 4.8;
+                    readonly p_value: 0.018;
+                    readonly srm_detected: 0;
+                }];
+            };
+        };
+        readonly useCase: "Drive a chart of metric movement over the experiment runtime, or sanity-check the lift is monotonic before deciding.";
+    }, {
+        readonly operationId: "reanalyzeExperiment";
+        readonly method: "POST";
+        readonly path: "/{id}/reanalyze";
+        readonly summary: "Re-queue analysis";
+        readonly description: "Requeues the daily analysis pass for this experiment outside the normal cron cadence. Useful after attaching a new metric or correcting an event taxonomy. The job runs asynchronously.";
+        readonly pathParams: {
+            readonly id: "Stable opaque experiment id.";
+        };
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            queued: zod.ZodLiteral<true>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1";
+                readonly queued: true;
+            };
+        };
+        readonly useCase: "Force-refresh results after wiring up a new metric without waiting for the next nightly cron tick.";
+    }];
+}, {
+    readonly name: "configs";
+    readonly basePath: "/api/admin/configs";
+    readonly describeOne: "config";
+    readonly describeMany: "configs";
+    readonly tag: {
+        readonly name: "Configs";
+        readonly description: string;
+    };
+    readonly schemas: {
+        readonly create: zod.ZodObject<{
+            name: zod.ZodString;
+            description: zod.ZodOptional<zod.ZodString>;
+            schema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+            value: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodUnknown, zod.ZodRecord<zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, zod.ZodUnknown>]>>;
+        }, zod_v4_core.$strip>;
+        readonly update: zod.ZodObject<{
+            schema: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            value: zod.ZodOptional<zod.ZodUnknown>;
+        }, zod_v4_core.$strip>;
+        readonly saveDraft: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            value: zod.ZodUnknown;
+        }, zod_v4_core.$strip>;
+        readonly publish: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+        }, zod_v4_core.$strip>;
+    };
+    readonly actions: readonly [{
+        readonly name: "publish";
+        readonly description: "Publish a config draft for an env";
+    }, {
+        readonly name: "saveDraft";
+        readonly description: "Save a draft value for an env";
+    }, {
+        readonly name: "discardDraft";
+        readonly description: "Discard a draft for an env";
+    }];
+    readonly endpoints: readonly [{
+        readonly operationId: "listConfigs";
+        readonly method: "GET";
+        readonly path: "";
+        readonly summary: "List dynamic configs";
+        readonly description: "Returns a single page of configs ordered by `updated_at desc, id desc`. Each row includes the latest published `version` per env and any active drafts.";
+        readonly response: zod.ZodObject<{
+            data: zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                description: zod.ZodNullable<zod.ZodString>;
+                schema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+                updatedAt: zod.ZodString;
+                envs: zod.ZodRecord<zod.ZodEnum<{
+                    dev: "dev";
+                    staging: "staging";
+                    prod: "prod";
+                }>, zod.ZodObject<{
+                    version: zod.ZodNumber;
+                    publishedAt: zod.ZodString;
+                    publishedBy: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+                drafts: zod.ZodRecord<zod.ZodEnum<{
+                    dev: "dev";
+                    staging: "staging";
+                    prod: "prod";
+                }>, zod.ZodObject<{
+                    updatedAt: zod.ZodString;
+                    authorEmail: zod.ZodString;
+                    baseVersion: zod.ZodNumber;
+                }, zod_v4_core.$strip>>;
+                values: zod.ZodOptional<zod.ZodRecord<zod.ZodEnum<{
+                    dev: "dev";
+                    staging: "staging";
+                    prod: "prod";
+                }>, zod.ZodUnknown>>;
+                draftValues: zod.ZodOptional<zod.ZodRecord<zod.ZodEnum<{
+                    dev: "dev";
+                    staging: "staging";
+                    prod: "prod";
+                }>, zod.ZodUnknown>>;
+            }, zod_v4_core.$strip>>;
+            next_cursor: zod.ZodNullable<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly data: readonly [{
+                    id: string;
+                    name: string;
+                    description: string;
+                    schema: {
+                        type: string;
+                        properties: {
+                            tiers: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            };
+                        };
+                        required: string[];
+                    };
+                    updatedAt: string;
+                    envs: {
+                        dev: {
+                            version: number;
+                            publishedAt: string;
+                            publishedBy: string;
+                        };
+                        stage: {
+                            version: number;
+                            publishedAt: string;
+                            publishedBy: string;
+                        };
+                        prod: {
+                            version: number;
+                            publishedAt: string;
+                            publishedBy: string;
+                        };
+                    };
+                    drafts: {
+                        dev: {
+                            updatedAt: string;
+                            authorEmail: string;
+                            baseVersion: number;
+                        };
+                    };
+                }];
+                readonly next_cursor: null;
+            };
+        };
+        readonly useCase: "Snapshot every config in the project — e.g. CI check that asserts no env is stuck on a stale default or that every config has a published value on prod.";
+    }, {
+        readonly operationId: "getConfig";
+        readonly method: "GET";
+        readonly path: "/{id}";
+        readonly summary: "Get one config";
+        readonly description: "Returns config metadata plus the latest published values per env and any active draft values. Use this to fetch the JSON the editor renders.";
+        readonly pathParams: {
+            readonly id: "Stable opaque config id (`cfg_…`) or the config's `name`.";
+        };
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+            description: zod.ZodNullable<zod.ZodString>;
+            schema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+            updatedAt: zod.ZodString;
+            envs: zod.ZodRecord<zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, zod.ZodObject<{
+                version: zod.ZodNumber;
+                publishedAt: zod.ZodString;
+                publishedBy: zod.ZodString;
+            }, zod_v4_core.$strip>>;
+            drafts: zod.ZodRecord<zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, zod.ZodObject<{
+                updatedAt: zod.ZodString;
+                authorEmail: zod.ZodString;
+                baseVersion: zod.ZodNumber;
+            }, zod_v4_core.$strip>>;
+            values: zod.ZodOptional<zod.ZodRecord<zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, zod.ZodUnknown>>;
+            draftValues: zod.ZodOptional<zod.ZodRecord<zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, zod.ZodUnknown>>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly values: {
+                    readonly dev: {
+                        readonly tiers: readonly [{
+                            readonly name: "free";
+                        }, {
+                            readonly name: "pro";
+                        }];
+                    };
+                    readonly stage: {
+                        readonly tiers: readonly [{
+                            readonly name: "free";
+                        }, {
+                            readonly name: "pro";
+                        }];
+                    };
+                    readonly prod: {
+                        readonly tiers: readonly [{
+                            readonly name: "free";
+                        }, {
+                            readonly name: "pro";
+                        }];
+                    };
+                };
+                readonly draftValues: {
+                    readonly dev: {
+                        readonly tiers: readonly [{
+                            readonly name: "free";
+                        }, {
+                            readonly name: "pro";
+                        }, {
+                            readonly name: "enterprise";
+                        }];
+                    };
+                };
+                readonly id: string;
+                readonly name: string;
+                readonly description: string;
+                readonly schema: {
+                    type: string;
+                    properties: {
+                        tiers: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        };
+                    };
+                    required: string[];
+                };
+                readonly updatedAt: string;
+                readonly envs: {
+                    dev: {
+                        version: number;
+                        publishedAt: string;
+                        publishedBy: string;
+                    };
+                    stage: {
+                        version: number;
+                        publishedAt: string;
+                        publishedBy: string;
+                    };
+                    prod: {
+                        version: number;
+                        publishedAt: string;
+                        publishedBy: string;
+                    };
+                };
+                readonly drafts: {
+                    dev: {
+                        updatedAt: string;
+                        authorEmail: string;
+                        baseVersion: number;
+                    };
+                };
+            };
+        };
+        readonly useCase: "Fetch one config's current published values and any in-flight drafts.";
+    }, {
+        readonly operationId: "createConfig";
+        readonly method: "POST";
+        readonly path: "";
+        readonly summary: "Create a dynamic config";
+        readonly description: string;
+        readonly successStatus: 201;
+        readonly request: zod.ZodObject<{
+            name: zod.ZodString;
+            description: zod.ZodOptional<zod.ZodString>;
+            schema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+            value: zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodUnknown, zod.ZodRecord<zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, zod.ZodUnknown>]>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly minimal: {
+                    readonly summary: "Minimal — name + schema";
+                    readonly description: "Smallest valid body. Initial value defaults to `{}` on every env.";
+                    readonly value: {
+                        readonly name: "pricing.tiers";
+                        readonly schema: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly tiers: {
+                                    readonly type: "array";
+                                };
+                            };
+                            readonly required: readonly ["tiers"];
+                        };
+                    };
+                };
+                readonly seededValue: {
+                    readonly summary: "Seeded — schema + initial value";
+                    readonly description: "Seed the same JSON object on every env at version 1.";
+                    readonly value: {
+                        readonly name: "pricing.tiers";
+                        readonly description: "Pricing tier definitions consumed by checkout.";
+                        readonly schema: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly tiers: {
+                                    readonly type: "array";
+                                };
+                            };
+                            readonly required: readonly ["tiers"];
+                        };
+                        readonly value: {
+                            readonly tiers: readonly [{
+                                readonly name: "free";
+                            }, {
+                                readonly name: "pro";
+                            }];
+                        };
+                    };
+                };
+                readonly perEnvSeed: {
+                    readonly summary: "Per-env seed";
+                    readonly description: "Pass a `{ env: value }` map to seed different initial values per env.";
+                    readonly value: {
+                        readonly name: "pricing.tiers";
+                        readonly schema: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly tiers: {
+                                    readonly type: "array";
+                                };
+                            };
+                            readonly required: readonly ["tiers"];
+                        };
+                        readonly value: {
+                            readonly dev: {
+                                readonly tiers: readonly [{
+                                    readonly name: "free";
+                                }, {
+                                    readonly name: "pro";
+                                }, {
+                                    readonly name: "enterprise";
+                                }];
+                            };
+                            readonly stage: {
+                                readonly tiers: readonly [{
+                                    readonly name: "free";
+                                }, {
+                                    readonly name: "pro";
+                                }];
+                            };
+                            readonly prod: {
+                                readonly tiers: readonly [{
+                                    readonly name: "free";
+                                }, {
+                                    readonly name: "pro";
+                                }];
+                            };
+                        };
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4";
+                readonly name: "pricing.tiers";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "updateConfig";
+        readonly method: "PATCH";
+        readonly path: "/{id}";
+        readonly summary: "Update a dynamic config";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque config id.";
+        };
+        readonly request: zod.ZodObject<{
+            schema: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+            value: zod.ZodOptional<zod.ZodUnknown>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly flatValue: {
+                    readonly summary: "Flat value — republish on every env";
+                    readonly description: "Sets the same JSON object as a new version on dev/stage/prod.";
+                    readonly value: {
+                        readonly value: {
+                            readonly tiers: readonly [{
+                                readonly name: "free";
+                            }, {
+                                readonly name: "pro";
+                            }];
+                        };
+                    };
+                };
+                readonly schemaOnly: {
+                    readonly summary: "Schema-only update";
+                    readonly description: "Replaces the schema. Existing values must still validate or the update fails.";
+                    readonly value: {
+                        readonly schema: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly tiers: {
+                                    readonly type: "array";
+                                };
+                                readonly trial_days: {
+                                    readonly type: "integer";
+                                };
+                            };
+                            readonly required: readonly ["tiers"];
+                        };
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "deleteConfig";
+        readonly method: "DELETE";
+        readonly path: "/{id}";
+        readonly summary: "Delete a dynamic config";
+        readonly description: "Soft-deletes the config and rebuilds the project's flags KV blob.";
+        readonly pathParams: {
+            readonly id: "Stable opaque config id.";
+        };
+        readonly response: zod.ZodObject<{
+            ok: zod.ZodLiteral<true>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly ok: true;
+            };
+        };
+        readonly useCase: "Tear down a config after its consumers have stopped reading it.";
+    }, {
+        readonly operationId: "saveConfigDraft";
+        readonly method: "PUT";
+        readonly path: "/{id}/drafts";
+        readonly summary: "Save a draft value";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque config id.";
+        };
+        readonly request: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            value: zod.ZodUnknown;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            baseVersion: zod.ZodNumber;
+            updatedAt: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly stageDev: {
+                    readonly summary: "Stage a dev draft";
+                    readonly description: "Stages a new value on dev without touching stage/prod.";
+                    readonly value: {
+                        readonly env: "dev";
+                        readonly value: {
+                            readonly tiers: readonly [{
+                                readonly name: "free";
+                            }, {
+                                readonly name: "pro";
+                            }, {
+                                readonly name: "enterprise";
+                            }];
+                        };
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4";
+                readonly env: "dev";
+                readonly baseVersion: 5;
+                readonly updatedAt: "2026-05-10T09:31:00.000Z";
+            };
+        };
+        readonly useCase: "Iterate on a config value on dev without affecting prod — preview in staging, then publish.";
+    }, {
+        readonly operationId: "discardConfigDraft";
+        readonly method: "DELETE";
+        readonly path: "/{id}/drafts";
+        readonly summary: "Discard a draft";
+        readonly description: "Drops the in-flight draft on one env. Published values are unaffected.";
+        readonly pathParams: {
+            readonly id: "Stable opaque config id.";
+        };
+        readonly request: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            ok: zod.ZodLiteral<true>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly discardDev: {
+                    readonly summary: "Discard the dev draft";
+                    readonly description: "Drops the staged dev draft without publishing.";
+                    readonly value: {
+                        readonly env: "dev";
+                    };
+                };
+            };
+            readonly response: {
+                readonly ok: true;
+            };
+        };
+        readonly useCase: "Abandon an in-progress draft after deciding not to ship it.";
+    }, {
+        readonly operationId: "publishConfigDraft";
+        readonly method: "POST";
+        readonly path: "/{id}/publish";
+        readonly summary: "Publish a draft";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque config id.";
+        };
+        readonly request: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            version: zod.ZodNumber;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly publishDev: {
+                    readonly summary: "Publish the dev draft";
+                    readonly description: "Promotes the dev draft to a new published version on dev.";
+                    readonly value: {
+                        readonly env: "dev";
+                    };
+                };
+                readonly publishProd: {
+                    readonly summary: "Publish to prod";
+                    readonly description: "Promotes the prod draft after staging signed off.";
+                    readonly value: {
+                        readonly env: "prod";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4";
+                readonly env: "dev";
+                readonly version: 6;
+            };
+        };
+        readonly useCase: "Ship a staged change once you've validated it on a lower env.";
+    }, {
+        readonly operationId: "listConfigActivity";
+        readonly method: "GET";
+        readonly path: "/{id}/activity";
+        readonly summary: "List config activity";
+        readonly description: "Returns recent audit rows for one config (create, update, draft.save, publish, delete) ordered newest first. Use the `limit` query parameter to cap the result (1–100, default 20).";
+        readonly pathParams: {
+            readonly id: "Stable opaque config id.";
+        };
+        readonly queryParams: {
+            readonly limit: {
+                readonly schema: zod.ZodDefault<zod.ZodCoercedNumber<unknown>>;
+                readonly description: "Max rows to return (1–100). Defaults to 20.";
+            };
+        };
+        readonly response: zod.ZodArray<zod.ZodObject<{
+            id: zod.ZodString;
+            action: zod.ZodString;
+            actorEmail: zod.ZodString;
+            actorType: zod.ZodEnum<{
+                user: "user";
+                cli: "cli";
+                system: "system";
+            }>;
+            payload: zod.ZodNullable<zod.ZodUnknown>;
+            createdAt: zod.ZodString;
+        }, zod_v4_core.$strip>>;
+        readonly examples: {
+            readonly response: readonly [{
+                readonly id: "act_01j7waf01a2b3c4d5e6f7g8h9i";
+                readonly action: "config.publish";
+                readonly actorEmail: "ana@example.com";
+                readonly actorType: "user";
+                readonly payload: {
+                    readonly env: "dev";
+                    readonly version: 6;
+                };
+                readonly createdAt: "2026-05-10T09:31:42.000Z";
+            }];
+        };
+        readonly useCase: "Render the activity panel in the config editor or drive a slack notification on publish events.";
+    }];
+}, {
+    readonly name: "universes";
+    readonly basePath: "/api/admin/universes";
+    readonly describeOne: "universe";
+    readonly describeMany: "universes";
+    readonly tag: {
+        readonly name: "Universes";
+        readonly description: string;
+    };
+    readonly schemas: {
+        readonly create: zod.ZodObject<{
+            name: zod.ZodString;
+            unit_type: zod.ZodDefault<zod.ZodString>;
+            holdout_range: zod.ZodDefault<zod.ZodNullable<zod.ZodTuple<[zod.ZodNumber, zod.ZodNumber], null>>>;
+        }, zod_v4_core.$strip>;
+        readonly update: zod.ZodObject<{
+            holdout_range: zod.ZodOptional<zod.ZodNullable<zod.ZodTuple<[zod.ZodNumber, zod.ZodNumber], null>>>;
+        }, zod_v4_core.$strip>;
+    };
+    readonly actions: readonly [];
+    readonly endpoints: readonly [{
+        readonly operationId: "listUniverses";
+        readonly method: "GET";
+        readonly path: "";
+        readonly summary: "List universes";
+        readonly description: "Returns a single page of universes ordered by `created_at desc, id desc`. The universes table has no `updated_at`, so this list is keyed on creation time.";
+        readonly response: zod.ZodObject<{
+            data: zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                unitType: zod.ZodString;
+                holdoutRange: zod.ZodNullable<zod.ZodTuple<[zod.ZodNumber, zod.ZodNumber], null>>;
+                createdAt: zod.ZodString;
+            }, zod_v4_core.$strip>>;
+            next_cursor: zod.ZodNullable<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly data: readonly [{
+                    readonly id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0";
+                    readonly name: "primary_users";
+                    readonly unitType: "user_id";
+                    readonly holdoutRange: readonly [9500, 9999];
+                    readonly createdAt: "2026-04-12T10:14:08.000Z";
+                }];
+                readonly next_cursor: null;
+            };
+        };
+        readonly useCase: "Snapshot every universe in the project — for example to audit which `unit_type` and `holdout_range` are in use before launching a new experiment.";
+    }, {
+        readonly operationId: "createUniverse";
+        readonly method: "POST";
+        readonly path: "";
+        readonly summary: "Create a universe";
+        readonly description: string;
+        readonly successStatus: 201;
+        readonly request: zod.ZodObject<{
+            name: zod.ZodString;
+            unit_type: zod.ZodDefault<zod.ZodString>;
+            holdout_range: zod.ZodDefault<zod.ZodNullable<zod.ZodTuple<[zod.ZodNumber, zod.ZodNumber], null>>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly minimal: {
+                    readonly summary: "Minimal — name only";
+                    readonly description: "Smallest valid body. Creates a `user_id`-keyed universe with no holdout.";
+                    readonly value: {
+                        readonly name: "primary_users";
+                    };
+                };
+                readonly holdout: {
+                    readonly summary: "Holdout — reserve 5% for measurement";
+                    readonly description: "Reserves buckets 9500–9999 (5% of callers) as the holdout. Pro plan or higher.";
+                    readonly value: {
+                        readonly name: "primary_users";
+                        readonly holdout_range: readonly [9500, 9999];
+                    };
+                };
+                readonly accountLevel: {
+                    readonly summary: "Account-level randomisation";
+                    readonly description: "Bucket whole accounts together via `unit_type: 'account_id'`.";
+                    readonly value: {
+                        readonly name: "saas_accounts";
+                        readonly unit_type: "account_id";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0";
+                readonly name: "primary_users";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "updateUniverse";
+        readonly method: "PATCH";
+        readonly path: "/{id}";
+        readonly summary: "Update a universe";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque universe id (`uni_…`).";
+        };
+        readonly request: zod.ZodObject<{
+            holdout_range: zod.ZodOptional<zod.ZodNullable<zod.ZodTuple<[zod.ZodNumber, zod.ZodNumber], null>>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly setHoldout: {
+                    readonly summary: "Set holdout — reserve 5%";
+                    readonly description: "Reserve buckets 9500–9999 as the holdout. Pro plan or higher.";
+                    readonly value: {
+                        readonly holdout_range: readonly [9500, 9999];
+                    };
+                };
+                readonly removeHoldout: {
+                    readonly summary: "Remove holdout";
+                    readonly description: "Disable the holdout entirely.";
+                    readonly value: {
+                        readonly holdout_range: null;
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "deleteUniverse";
+        readonly method: "DELETE";
+        readonly path: "/{id}";
+        readonly summary: "Delete a universe";
+        readonly description: "Soft-deletes the universe. Returns `409` if any non-archived experiment still references it — archive those experiments first.";
+        readonly pathParams: {
+            readonly id: "Stable opaque universe id.";
+        };
+        readonly response: zod.ZodObject<{
+            ok: zod.ZodLiteral<true>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly ok: true;
+            };
+        };
+        readonly useCase: "Tear down a universe after every experiment that used it has been archived.";
+    }];
+}, {
+    readonly name: "killswitches";
+    readonly basePath: "/api/admin/killswitches";
+    readonly describeOne: "killswitch";
+    readonly describeMany: "killswitches";
+    readonly tag: {
+        readonly name: "Killswitches";
+        readonly description: string;
+    };
+    readonly schemas: {
+        readonly create: zod.ZodObject<{
+            name: zod.ZodString;
+            description: zod.ZodOptional<zod.ZodString>;
+            value: zod.ZodOptional<zod.ZodBoolean>;
+            switches: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodBoolean>>;
+        }, zod_v4_core.$strip>;
+        readonly update: zod.ZodObject<{
+            description: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            value: zod.ZodOptional<zod.ZodBoolean>;
+            switches: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodBoolean>>;
+        }, zod_v4_core.$strip>;
+        readonly setSwitch: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: zod.ZodString;
+            value: zod.ZodBoolean;
+        }, zod_v4_core.$strip>;
+        readonly unsetSwitch: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: zod.ZodString;
+        }, zod_v4_core.$strip>;
+    };
+    readonly actions: readonly [{
+        readonly name: "setSwitch";
+        readonly description: "Set or update one switch entry on one env";
+    }, {
+        readonly name: "unsetSwitch";
+        readonly description: "Remove one switch entry from one env";
+    }];
+    readonly endpoints: readonly [{
+        readonly operationId: "listKillswitches";
+        readonly method: "GET";
+        readonly path: "";
+        readonly summary: "List killswitches";
+        readonly description: "Returns a single page of killswitches ordered by `updated_at desc, id desc`. Each row includes the latest published `value`/`switches`/`version` per env.";
+        readonly response: zod.ZodObject<{
+            data: zod.ZodArray<zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                description: zod.ZodNullable<zod.ZodString>;
+                updatedAt: zod.ZodString;
+                envs: zod.ZodRecord<zod.ZodEnum<{
+                    dev: "dev";
+                    staging: "staging";
+                    prod: "prod";
+                }>, zod.ZodObject<{
+                    value: zod.ZodBoolean;
+                    switches: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodBoolean>>;
+                    version: zod.ZodNumber;
+                    publishedAt: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>>;
+            next_cursor: zod.ZodNullable<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly data: readonly [{
+                    id: string;
+                    name: string;
+                    description: string;
+                    updatedAt: string;
+                    envs: {
+                        dev: {
+                            value: boolean;
+                            version: number;
+                            publishedAt: string;
+                        };
+                        stage: {
+                            value: boolean;
+                            version: number;
+                            publishedAt: string;
+                        };
+                        prod: {
+                            value: boolean;
+                            switches: {
+                                eu_region: boolean;
+                            };
+                            version: number;
+                            publishedAt: string;
+                        };
+                    };
+                }];
+                readonly next_cursor: null;
+            };
+        };
+        readonly useCase: "Snapshot every killswitch in the project — e.g. to render an incident-response runbook listing every kill and its current trip state.";
+    }, {
+        readonly operationId: "getKillswitch";
+        readonly method: "GET";
+        readonly path: "/{id}";
+        readonly summary: "Get one killswitch";
+        readonly description: "Returns the killswitch metadata plus the latest published `value`/`switches`/`version` per env.";
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id (`ksw_…`).";
+        };
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+            description: zod.ZodNullable<zod.ZodString>;
+            updatedAt: zod.ZodString;
+            envs: zod.ZodRecord<zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>, zod.ZodObject<{
+                value: zod.ZodBoolean;
+                switches: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodBoolean>>;
+                version: zod.ZodNumber;
+                publishedAt: zod.ZodString;
+            }, zod_v4_core.$strip>>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                id: string;
+                name: string;
+                description: string;
+                updatedAt: string;
+                envs: {
+                    dev: {
+                        value: boolean;
+                        version: number;
+                        publishedAt: string;
+                    };
+                    stage: {
+                        value: boolean;
+                        version: number;
+                        publishedAt: string;
+                    };
+                    prod: {
+                        value: boolean;
+                        switches: {
+                            eu_region: boolean;
+                        };
+                        version: number;
+                        publishedAt: string;
+                    };
+                };
+            };
+        };
+        readonly useCase: "Fetch the current state of one killswitch — e.g. to verify a trip propagated before declaring an incident mitigated.";
+    }, {
+        readonly operationId: "createKillswitch";
+        readonly method: "POST";
+        readonly path: "";
+        readonly summary: "Create a killswitch";
+        readonly description: string;
+        readonly successStatus: 201;
+        readonly request: zod.ZodObject<{
+            name: zod.ZodString;
+            description: zod.ZodOptional<zod.ZodString>;
+            value: zod.ZodOptional<zod.ZodBoolean>;
+            switches: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodBoolean>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly minimal: {
+                    readonly summary: "Minimal — name only, untripped";
+                    readonly description: "Smallest valid body. Creates a killswitch with `value: false` on every env.";
+                    readonly value: {
+                        readonly name: "payments.checkout";
+                    };
+                };
+                readonly preTripped: {
+                    readonly summary: "Pre-tripped on create";
+                    readonly description: "Ship the killswitch already tripped (`value: true`) — useful when provisioning a kill ahead of a deploy you want to ship with the feature off.";
+                    readonly value: {
+                        readonly name: "payments.checkout";
+                        readonly description: "Master kill for the new checkout flow.";
+                        readonly value: true;
+                    };
+                };
+                readonly withSwitches: {
+                    readonly summary: "With per-region switches";
+                    readonly description: "Seed a `switches` map so specific named call sites can be tripped independently of the flat `value`.";
+                    readonly value: {
+                        readonly name: "payments.checkout";
+                        readonly value: false;
+                        readonly switches: {
+                            readonly eu_region: true;
+                            readonly apac_region: false;
+                        };
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+                readonly name: "payments.checkout";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "updateKillswitch";
+        readonly method: "PATCH";
+        readonly path: "/{id}";
+        readonly summary: "Update a killswitch";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly request: zod.ZodObject<{
+            description: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+            value: zod.ZodOptional<zod.ZodBoolean>;
+            switches: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodBoolean>>;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly trip: {
+                    readonly summary: "Trip the killswitch on every env";
+                    readonly description: "Sets `value: true` on dev/stage/prod, bumping each env's version by one.";
+                    readonly value: {
+                        readonly value: true;
+                    };
+                };
+                readonly untrip: {
+                    readonly summary: "Untrip on every env";
+                    readonly description: "Sets `value: false` on every env.";
+                    readonly value: {
+                        readonly value: false;
+                    };
+                };
+                readonly replaceSwitches: {
+                    readonly summary: "Replace switches map";
+                    readonly description: "Replaces the per-key overrides wholesale on every env. Pass `{}` to clear.";
+                    readonly value: {
+                        readonly switches: {
+                            readonly eu_region: true;
+                            readonly apac_region: true;
+                        };
+                    };
+                };
+                readonly updateDescription: {
+                    readonly summary: "Description-only update";
+                    readonly description: "Doesn't bump versions or trigger a republish — only metadata changes.";
+                    readonly value: {
+                        readonly description: "Master kill — owner: payments-platform";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "deleteKillswitch";
+        readonly method: "DELETE";
+        readonly path: "/{id}";
+        readonly summary: "Delete a killswitch";
+        readonly description: "Soft-deletes the killswitch and rebuilds the project's flags KV blob so SDKs stop seeing it.";
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly response: zod.ZodObject<{
+            ok: zod.ZodLiteral<true>;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly response: {
+                readonly ok: true;
+            };
+        };
+        readonly useCase: "Tear down a killswitch after the feature it protected has been removed.";
+    }, {
+        readonly operationId: "setKillswitchSwitch";
+        readonly method: "PUT";
+        readonly path: "/{id}/switch";
+        readonly summary: "Set one switch entry";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly request: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: zod.ZodString;
+            value: zod.ZodBoolean;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: zod.ZodString;
+            value: zod.ZodBoolean;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly tripRegion: {
+                    readonly summary: "Trip eu_region on prod";
+                    readonly description: "Sets `switches.eu_region = true` on prod only. Other envs and the flat `value` are unchanged.";
+                    readonly value: {
+                        readonly env: "prod";
+                        readonly switchKey: "eu_region";
+                        readonly value: true;
+                    };
+                };
+                readonly untripRegion: {
+                    readonly summary: "Untrip eu_region on prod";
+                    readonly description: "Flip the same entry back off without removing it from the map.";
+                    readonly value: {
+                        readonly env: "prod";
+                        readonly switchKey: "eu_region";
+                        readonly value: false;
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+                readonly env: "prod";
+                readonly switchKey: "eu_region";
+                readonly value: true;
+            };
+        };
+        readonly useCase: string;
+    }, {
+        readonly operationId: "unsetKillswitchSwitch";
+        readonly method: "DELETE";
+        readonly path: "/{id}/switch";
+        readonly summary: "Remove one switch entry";
+        readonly description: string;
+        readonly pathParams: {
+            readonly id: "Stable opaque killswitch id.";
+        };
+        readonly request: zod.ZodObject<{
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: zod.ZodString;
+        }, zod_v4_core.$strip>;
+        readonly response: zod.ZodObject<{
+            id: zod.ZodString;
+            env: zod.ZodEnum<{
+                dev: "dev";
+                staging: "staging";
+                prod: "prod";
+            }>;
+            switchKey: zod.ZodString;
+            removed: zod.ZodBoolean;
+        }, zod_v4_core.$strip>;
+        readonly examples: {
+            readonly requestExamples: {
+                readonly removeRegion: {
+                    readonly summary: "Remove eu_region from prod";
+                    readonly description: "Drops the `eu_region` override on prod so the flat `value` applies again.";
+                    readonly value: {
+                        readonly env: "prod";
+                        readonly switchKey: "eu_region";
+                    };
+                };
+            };
+            readonly response: {
+                readonly id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8";
+                readonly env: "prod";
+                readonly switchKey: "eu_region";
+                readonly removed: true;
+            };
+        };
+        readonly useCase: "Clean up a per-region override after the incident is resolved so the flat `value` governs again.";
+    }];
+}];
+
+export { type AdminClient, RESOURCE_REGISTRY, createAdminClient };