@shipeasy/openapi 1.0.0

package/dist/resources/gates.d.ts

@@ -0,0 +1,670 @@
+import { z } from 'zod';
+import { GateCreateInput, GateUpdateInput } from '@shipeasy/core/schemas/gates';
+export { GateCreateInput, GateUpdateInput } from '@shipeasy/core/schemas/gates';
+import { PageQuery, Page } from '@shipeasy/core/pagination';
+import { Transport } from '../transport.js';
+
+/** Gate row as returned by `GET /api/admin/gates`. Booleans come back as 0/1 from D1. */
+interface Gate {
+    id: string;
+    name: string;
+    enabled: number | boolean;
+    rolloutPct: number;
+    rules?: unknown[];
+    salt?: string;
+    updatedAt: string;
+}
+interface GatesClient {
+    /** Single page of gates ordered `(updated_at desc, id desc)`. */
+    list(opts?: Partial<PageQuery>): Promise<Page<Gate>>;
+    /** Drain every page. Use for small datasets or batch CLI jobs. */
+    listAll(): Promise<Gate[]>;
+    /** Server has no GET /:id endpoint — resolved by paging through and filtering. */
+    getByName(name: string): Promise<Gate>;
+    /** Same as getByName but accepts either `id` or `name` (id wins if both match). */
+    resolve(idOrName: string): Promise<Gate>;
+    create(input: GateCreateInput): Promise<{
+        id: string;
+        name: string;
+    }>;
+    update(id: string, input: GateUpdateInput): Promise<{
+        id: string;
+    }>;
+    delete(id: string): Promise<{
+        ok: true;
+    }>;
+    enable(id: string): Promise<{
+        id: string;
+        enabled: boolean;
+    }>;
+    disable(id: string): Promise<{
+        id: string;
+        enabled: boolean;
+    }>;
+    /** Convenience: resolve by name, then PATCH rollout_pct. `pct` is 0–100 (decimals OK). */
+    setRollout(name: string, pct: number): Promise<{
+        id: string;
+    }>;
+}
+declare function gatesClient(t: Transport): GatesClient;
+/**
+ * Resource descriptor for the registry. MCP iterates this to auto-generate
+ * its tool catalog; CLI iterates it to auto-wire commander subcommands.
+ *
+ * `inputSchema` fields are zod schemas — convert with `z.toJSONSchema()` for
+ * MCP `inputSchema` JSON Schema, parse directly for CLI option validation.
+ */
+declare const gatesResource: {
+    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: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            folder: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+            owner_email: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            rollout_pct: z.ZodDefault<z.ZodNumber>;
+            rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                attr: z.ZodString;
+                op: z.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: z.ZodUnknown;
+            }, z.core.$strip>>>;
+            salt: z.ZodOptional<z.ZodString>;
+            stack: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"condition">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                pass: z.ZodOptional<z.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    attr: z.ZodString;
+                    op: z.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: z.ZodUnknown;
+                }, z.core.$strip>>>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"rollout">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rolloutPct: z.ZodNumber;
+                bucketBy: z.ZodOptional<z.ZodString>;
+                salt: z.ZodOptional<z.ZodString>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>], "type">>>>;
+        }, z.core.$strip>;
+        readonly update: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            folder: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+            owner_email: z.ZodOptional<z.ZodString>;
+            rollout_pct: z.ZodOptional<z.ZodNumber>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attr: z.ZodString;
+                op: z.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: z.ZodUnknown;
+            }, z.core.$strip>>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            stack: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"condition">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                pass: z.ZodOptional<z.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    attr: z.ZodString;
+                    op: z.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: z.ZodUnknown;
+                }, z.core.$strip>>>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"rollout">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rolloutPct: z.ZodNumber;
+                bucketBy: z.ZodOptional<z.ZodString>;
+                salt: z.ZodOptional<z.ZodString>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>], "type">>>>;
+        }, z.core.$strip>;
+    };
+    /** Custom action endpoints beyond CRUD (POST <basePath>/:id/<action>). */
+    readonly actions: readonly [{
+        readonly name: "enable";
+        readonly description: "Enable a gate";
+    }, {
+        readonly name: "disable";
+        readonly description: "Disable a gate";
+    }];
+    /**
+     * Full operation list for the OpenAPI doc. Order here is the order shown in
+     * the docs sidebar. The typed client (`gatesClient`) is the runtime contract;
+     * this is the documented surface.
+     */
+    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: z.ZodObject<{
+            data: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber]>;
+                rolloutPct: z.ZodNumber;
+                rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    attr: z.ZodString;
+                    op: z.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: z.ZodUnknown;
+                }, z.core.$strip>>>;
+                salt: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                groupName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                ownerEmail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stack: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"condition">;
+                    name: z.ZodOptional<z.ZodString>;
+                    fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    pass: z.ZodOptional<z.ZodEnum<{
+                        all: "all";
+                        any: "any";
+                    }>>;
+                    rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        attr: z.ZodString;
+                        op: z.ZodEnum<{
+                            eq: "eq";
+                            neq: "neq";
+                            in: "in";
+                            not_in: "not_in";
+                            gt: "gt";
+                            gte: "gte";
+                            lt: "lt";
+                            lte: "lte";
+                            contains: "contains";
+                            regex: "regex";
+                        }>;
+                        value: z.ZodUnknown;
+                    }, z.core.$strip>>>;
+                    locked: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodLiteral<"rollout">;
+                    name: z.ZodOptional<z.ZodString>;
+                    fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    rolloutPct: z.ZodNumber;
+                    bucketBy: z.ZodOptional<z.ZodString>;
+                    salt: z.ZodOptional<z.ZodString>;
+                    locked: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>], "type">>>>;
+                updatedAt: z.ZodString;
+            }, z.core.$strip>>;
+            next_cursor: z.ZodNullable<z.ZodString>;
+        }, z.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: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            folder: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+            owner_email: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            rollout_pct: z.ZodDefault<z.ZodNumber>;
+            rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                attr: z.ZodString;
+                op: z.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: z.ZodUnknown;
+            }, z.core.$strip>>>;
+            salt: z.ZodOptional<z.ZodString>;
+            stack: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"condition">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                pass: z.ZodOptional<z.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    attr: z.ZodString;
+                    op: z.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: z.ZodUnknown;
+                }, z.core.$strip>>>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"rollout">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rolloutPct: z.ZodNumber;
+                bucketBy: z.ZodOptional<z.ZodString>;
+                salt: z.ZodOptional<z.ZodString>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>], "type">>>>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.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: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            folder: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+            owner_email: z.ZodOptional<z.ZodString>;
+            rollout_pct: z.ZodOptional<z.ZodNumber>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                attr: z.ZodString;
+                op: z.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    not_in: "not_in";
+                    gt: "gt";
+                    gte: "gte";
+                    lt: "lt";
+                    lte: "lte";
+                    contains: "contains";
+                    regex: "regex";
+                }>;
+                value: z.ZodUnknown;
+            }, z.core.$strip>>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            stack: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"condition">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                pass: z.ZodOptional<z.ZodEnum<{
+                    all: "all";
+                    any: "any";
+                }>>;
+                rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    attr: z.ZodString;
+                    op: z.ZodEnum<{
+                        eq: "eq";
+                        neq: "neq";
+                        in: "in";
+                        not_in: "not_in";
+                        gt: "gt";
+                        gte: "gte";
+                        lt: "lt";
+                        lte: "lte";
+                        contains: "contains";
+                        regex: "regex";
+                    }>;
+                    value: z.ZodUnknown;
+                }, z.core.$strip>>>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"rollout">;
+                name: z.ZodOptional<z.ZodString>;
+                fromTemplate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                rolloutPct: z.ZodNumber;
+                bucketBy: z.ZodOptional<z.ZodString>;
+                salt: z.ZodOptional<z.ZodString>;
+                locked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>], "type">>>>;
+        }, z.core.$strip>;
+        readonly response: z.ZodObject<{
+            id: z.ZodString;
+        }, z.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: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.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: z.ZodObject<{
+            id: z.ZodString;
+            enabled: z.ZodBoolean;
+        }, z.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: z.ZodObject<{
+            id: z.ZodString;
+            enabled: z.ZodBoolean;
+        }, z.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.";
+    }];
+};
+
+export { type Gate, type GatesClient, gatesClient, gatesResource };