@shipeasy/openapi 1.5.0 → 2.1.0

package/dist/resources/gates.js

@@ -1,522 +0,0 @@
-// src/resources/gates.ts
-import { z as z3 } from "zod";
-
-// src/schemas/gates.ts
-import { z as z2 } from "zod";
-
-// src/schemas/folder.ts
-import { z } from "zod";
-var folderSchema = z.string().max(256).regex(/^[a-zA-Z0-9_-]+$/, "Folder must be alphanumeric, `_` or `-` (no `/`).").nullable().optional().describe(
-  "Optional folder name used to group items in the dashboard. Part of the SDK lookup key: an item in folder `checkout` named `new-cart` is referenced as `checkout/new-cart` from the SDK."
-);
-
-// src/schemas/gates.ts
-var gateRuleSchema = z2.object({
-  attr: z2.string().min(1).describe(
-    "Attribute key on the evaluation context (e.g. `country`, `plan`, `email`). Matched case-sensitively against `Shipeasy.checkGate(user, name)` input."
-  ),
-  op: z2.enum([
-    "eq",
-    "neq",
-    "in",
-    "not_in",
-    "gt",
-    "gte",
-    "lt",
-    "lte",
-    "contains",
-    "regex",
-    "semver_gt",
-    "semver_gte",
-    "semver_lt",
-    "semver_lte",
-    "gate_pass",
-    "exp_in"
-  ]).describe(
-    'Comparison operator. Equality: `eq`/`neq`. Set membership: `in`/`not_in` (value is an array). Numeric order: `gt`/`gte`/`lt`/`lte`. Semver order: `semver_gt`/`semver_gte`/`semver_lt`/`semver_lte` (value is a dotted version like `4.2.0`). String: `contains` (substring), `regex` (JS-flavour pattern, value is the pattern string). Cross-resource references (evaluated only on the worker hot path, where both KV blobs load): `gate_pass` (`value` is another gate\'s name \u2014 true when that gate passes for the same caller); `exp_in` (`attr` is a running experiment\'s name, `value` is a group name, `"$holdout"`, or `"$any"` \u2014 true when the caller is in that variant / the universe holdout / any variant).'
-  ),
-  value: z2.unknown().describe(
-    'Operand. Shape depends on `op`: scalar for `eq/neq/gt/gte/lt/lte/contains/semver_*`; array of scalars for `in/not_in`; string pattern for `regex`; referenced gate name for `gate_pass`; group name / `"$holdout"` / `"$any"` for `exp_in`.'
-  )
-}).describe(
-  "Single targeting predicate. A gate's `rules` array is evaluated with AND semantics; use the gatekeeper `stack` for OR / fall-through logic."
-);
-var gateNameSchema = z2.string().regex(
-  /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/,
-  "lowercase, digits, _/-; optional folder.name shape"
-).max(128).describe(
-  "Stable gate key used by SDKs (`Shipeasy.checkGate(user, '<name>')`). Single segment or `folder.name`. Lowercase letters, digits, `_` or `-`; max 128 chars. Immutable after create \u2014 rename = delete + recreate."
-);
-var rampSchema = z2.object({
-  from: z2.number().int().min(0).max(1e4).describe("Start of the ramp in basis points (0\u201310000)."),
-  to: z2.number().int().min(0).max(1e4).describe("End of the ramp in basis points (0\u201310000)."),
-  startAt: z2.number().int().nonnegative().describe("Ramp start, epoch milliseconds (UTC)."),
-  durationMs: z2.number().int().positive().describe("Ramp length in milliseconds.")
-}).describe(
-  "Linear rollout ramp. The effective rollout % interpolates `from`\u2192`to` over `[startAt, startAt+durationMs]`, clamped outside that window, evaluated against the wall-clock at eval time. Overrides the entry's static `rolloutPct` while present."
-);
-var stackedConditionSchema = z2.object({
-  id: z2.string().min(1).describe(
-    "Client-supplied stable id for the stack entry (used for React keys, audit diffs, and as the default per-condition rollout salt)."
-  ),
-  type: z2.literal("condition").describe("Discriminator. `condition` = rule-based predicate sub-gate."),
-  name: z2.string().optional().describe("Human label shown in the dashboard."),
-  fromTemplate: z2.string().nullable().optional().describe(
-    "Id of the project template this entry was seeded from, or `null` if hand-authored."
-  ),
-  pass: z2.enum(["all", "any"]).optional().describe("Combinator across `rules`. `all` = AND (default), `any` = OR."),
-  rules: z2.array(gateRuleSchema).default([]).describe("Predicates evaluated under `pass`. Empty array = match nothing."),
-  rolloutPct: z2.number().int().min(0).max(1e4).optional().describe(
-    "Per-condition rollout in basis points. After the rules match, the caller is bucketed at this %; in-bucket \u2192 gate `true`, otherwise fall through to the next entry. Absent \u21D2 10000 (100%, every matching caller passes)."
-  ),
-  bucketBy: z2.string().optional().describe("Attribute used to hash the caller into the per-condition bucket. Default `userID`."),
-  salt: z2.string().optional().describe("Per-condition hash salt. Defaults to the entry `id`, then the gate salt."),
-  ramp: rampSchema.optional(),
-  locked: z2.boolean().optional().describe("If `true`, dashboard hides edit controls (e.g. the trailing public-floor entry).")
-}).describe(
-  "Rule-based sub-gate. When the rules match and the caller falls in the per-condition rollout bucket, evaluation short-circuits and the gate returns `true`; otherwise it falls through to the next entry."
-);
-var stackedRolloutSchema = z2.object({
-  id: z2.string().min(1).describe("Client-supplied stable id for the stack entry."),
-  type: z2.literal("rollout").describe("Discriminator. `rollout` = percentage-bucket sub-gate."),
-  name: z2.string().optional().describe("Human label shown in the dashboard."),
-  fromTemplate: z2.string().nullable().optional().describe("Source template id, or `null`."),
-  rolloutPct: z2.number().int().min(0).max(1e4).describe(
-    "Bucket size in basis points (0\u201310000 = 0%\u2013100%). `5000` = 50%, `100` = 1%, allows sub-1% precision."
-  ),
-  bucketBy: z2.string().optional().describe(
-    "Attribute used to hash the caller into a bucket. Defaults to `user.userID`. Use e.g. `accountID` to bucket whole accounts together."
-  ),
-  salt: z2.string().optional().describe(
-    "Per-entry hash salt. Defaults to the gate's salt. Set explicitly to keep two rollouts independent or correlated across gates."
-  ),
-  ramp: rampSchema.optional(),
-  locked: z2.boolean().optional().describe("If `true`, dashboard hides edit controls.")
-}).describe(
-  "Percentage-rollout sub-gate. Hashes `bucketBy` (default `userID`) with `salt` and returns `true` for `rolloutPct/10000` fraction of callers (or the ramp's effective % when `ramp` is set)."
-);
-var stackedGateEntrySchema = z2.discriminatedUnion("type", [stackedConditionSchema, stackedRolloutSchema]).describe(
-  "One entry in the ordered gatekeeper stack. Evaluated top-to-bottom; first matching entry decides. Mix `condition` and `rollout` entries to express `internal-only` + `1% beta` + `50% public` in a single gate."
-);
-var gateMetadataFields = {
-  title: z2.string().max(140).optional().describe("Human-readable title shown in the dashboard. Free-form, no key format constraint."),
-  description: z2.string().max(2e3).optional().describe("Long-form description / runbook. Markdown is rendered in the dashboard."),
-  folder: folderSchema,
-  group: z2.string().max(64).optional().describe("Group label for dashboard organisation (e.g. team or product area)."),
-  owner_email: z2.string().max(190).optional().describe("Owner contact. Displayed verbatim; not used for auth.")
-};
-var gateMetadataPatchSchema = z2.object(gateMetadataFields);
-var gateCreateSchema = z2.object({
-  name: gateNameSchema,
-  enabled: z2.boolean().default(true).describe(
-    "Master switch. Defaults to `true`. Set `false` to create the gate disabled (evaluates to `false` regardless of rules/rollout); flip on via `POST /{id}/enable` or PATCH."
-  ),
-  rollout_pct: z2.number().int().min(0).max(1e4).default(0).describe(
-    "Initial rollout in **basis points** (0\u201310000 = 0%\u2013100%) \u2014 `100` here means **1%**, not 100%. Use `rollout_percent` (0\u2013100) below if you'd rather think in percent. Use `0` to create the gate dark and ramp via PATCH after deploy validation."
-  ),
-  rollout_percent: z2.number().min(0).max(100).optional().describe(
-    "Initial rollout as a **percentage** (0\u2013100, fractional ok). Friendlier alias for `rollout_pct`; converted internally to basis points (e.g. `100` here = 10000 bp = 100%). If both `rollout_pct` and `rollout_percent` are set, `rollout_percent` wins."
-  ),
-  rules: z2.array(gateRuleSchema).default([]).describe(
-    "Targeting predicates. AND-combined. If non-empty, the gate returns `true` only for callers that satisfy every rule **and** fall under `rollout_pct`."
-  ),
-  salt: z2.string().min(1).max(64).optional().describe(
-    "Hash salt for percentage bucketing. Auto-generated if omitted. Provide explicitly to keep a gate's buckets stable across delete/recreate. **Immutable after create** \u2014 there is no PATCH for `salt` because changing it would re-bucket every caller."
-  ),
-  stack: z2.array(stackedGateEntrySchema).nullable().optional().describe(
-    "Optional gatekeeper stack. When provided, takes precedence over `rules` + `rollout_pct` at evaluation time. Omit (or pass `null`) for a flat gate."
-  ),
-  ...gateMetadataFields
-}).describe(
-  "Body for `POST /api/admin/gates`. At minimum supply `name`; everything else has sensible defaults."
-);
-var gateUpdateSchema = z2.object({
-  rollout_pct: z2.number().int().min(0).max(1e4).optional().describe(
-    "New rollout in **basis points** (0\u201310000 = 0%\u2013100%) \u2014 `100` here means **1%**. Use `rollout_percent` (0\u2013100) below for percent. Omit both to leave unchanged."
-  ),
-  rollout_percent: z2.number().min(0).max(100).optional().describe(
-    "New rollout as a **percentage** (0\u2013100). Friendlier alias for `rollout_pct`; converted internally. Wins over `rollout_pct` if both are supplied. Omit both to leave unchanged."
-  ),
-  rules: z2.array(gateRuleSchema).optional().describe(
-    "Replaces the rule list wholesale. To add a value to an `in` rule, send the full new `rules` array with the augmented `value` (e.g. previous `['US','CA']` \u2192 `['US','CA','GB']`)."
-  ),
-  enabled: z2.boolean().optional().describe(
-    "Master switch. `false` makes the gate evaluate to `false` for every caller regardless of `rollout_pct`, `rules`, or `stack` \u2014 use as kill switch."
-  ),
-  stack: z2.array(stackedGateEntrySchema).nullable().optional().describe(
-    "Replaces the gatekeeper stack wholesale. Send `null` to revert to flat `rules` + `rollout_pct` evaluation."
-  ),
-  ...gateMetadataFields
-}).describe(
-  "Body for `PATCH /api/admin/gates/{id}`. Partial \u2014 only supplied fields change. Array fields (`rules`, `stack`) replace, not merge."
-);
-var gateResponseSchema = z2.object({
-  id: z2.string().describe("Stable opaque gate id (`gat_\u2026`)."),
-  name: gateNameSchema,
-  /** D1 stores enabled as 0/1; clients see either form. */
-  enabled: z2.union([z2.boolean(), z2.number().int().min(0).max(1)]).describe("Master switch. Returned as `1`/`0` from D1; treat truthy as enabled."),
-  /** Rollout percentage in basis points (0–10000 = 0%–100%). */
-  rolloutPct: z2.number().int().min(0).max(1e4).describe("Current rollout in basis points (0\u201310000)."),
-  rules: z2.array(gateRuleSchema).optional(),
-  salt: z2.string().optional().describe("Hash salt used for percentage bucketing."),
-  title: z2.string().nullable().optional(),
-  description: z2.string().nullable().optional(),
-  folder: z2.string().nullable().optional(),
-  groupName: z2.string().nullable().optional().describe("Group label (note: `groupName` in response, `group` in request)."),
-  ownerEmail: z2.string().nullable().optional().describe("Owner email (note: `ownerEmail` in response, `owner_email` in request)."),
-  stack: z2.array(stackedGateEntrySchema).nullable().optional(),
-  updatedAt: z2.string().describe("ISO-8601 timestamp of last mutation.")
-});
-var gateCreateResponseSchema = z2.object({
-  id: z2.string().describe("Newly assigned gate id (`gat_\u2026`)."),
-  name: gateNameSchema
-});
-var gateUpdateResponseSchema = z2.object({ id: z2.string().describe("Gate id that was updated.") }).describe("Update returns only the id \u2014 re-fetch via `GET /api/admin/gates` for the full row.");
-var gateDeleteResponseSchema = z2.object({ ok: z2.literal(true) });
-var gateToggleResponseSchema = z2.object({
-  id: z2.string(),
-  enabled: z2.boolean()
-});
-
-// src/transport.ts
-var ApiError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "ApiError";
-  }
-  status;
-};
-
-// src/resources/gates.ts
-var gateListResponseSchema = z3.object({
-  data: z3.array(gateResponseSchema),
-  next_cursor: z3.string().nullable()
-});
-var BASE = "/api/admin/gates";
-function gatesClient(t) {
-  async function list(opts = {}) {
-    const query = {};
-    if (opts.limit !== void 0) query.limit = String(opts.limit);
-    if (opts.cursor) query.cursor = opts.cursor;
-    return t.request("GET", BASE, void 0, query);
-  }
-  async function listAll() {
-    const out = [];
-    let cursor;
-    do {
-      const page = await list({ limit: 500, cursor });
-      out.push(...page.data);
-      cursor = page.next_cursor ?? void 0;
-    } while (cursor);
-    return out;
-  }
-  async function resolve(idOrName) {
-    const all = await listAll();
-    const found = all.find((g) => g.id === idOrName) ?? all.find((g) => g.name === idOrName);
-    if (!found) throw new ApiError(`Gate '${idOrName}' not found`, 404);
-    return found;
-  }
-  return {
-    list,
-    listAll,
-    resolve,
-    getByName: async (name) => {
-      const found = (await listAll()).find((g) => g.name === name);
-      if (!found) throw new ApiError(`Gate '${name}' not found`, 404);
-      return found;
-    },
-    create: (input) => t.request("POST", BASE, gateCreateSchema.parse(input)),
-    update: (id, input) => t.request("PATCH", `${BASE}/${id}`, gateUpdateSchema.parse(input)),
-    delete: (id) => t.request("DELETE", `${BASE}/${id}`),
-    enable: (id) => t.request("POST", `${BASE}/${id}/enable`),
-    disable: (id) => t.request("POST", `${BASE}/${id}/disable`),
-    setRollout: async (name, pct) => {
-      if (!Number.isFinite(pct) || pct < 0 || pct > 100) {
-        throw new ApiError("rollout must be a number between 0 and 100", 400);
-      }
-      const gate = await resolve(name);
-      return t.request("PATCH", `${BASE}/${gate.id}`, {
-        rollout_pct: Math.round(pct * 100)
-      });
-    }
-  };
-}
-var gatesResource = {
-  name: "gates",
-  basePath: BASE,
-  describeOne: "feature gate",
-  describeMany: "feature gates",
-  tag: {
-    name: "Gates",
-    description: [
-      "Feature gates: boolean flags evaluated at runtime against project rules + a percentage rollout.",
-      "",
-      "**Identity.** Each gate is keyed by a stable `name` (a-z, 0-9, `_`/`-`, max 64 chars) which is what SDKs pass to `Shipeasy.checkGate(user, '<name>')`. The `name` is immutable \u2014 rename means delete + recreate.",
-      "",
-      "**Evaluation model.** A gate returns `true` when (a) `enabled` is true, and (b) the caller satisfies the gate's rules. There are two evaluation shapes:",
-      "- **Flat** \u2014 `rules` (AND-combined predicates) gate the caller, then `rollout_pct` (basis points, 0\u201310000) hashes them into a bucket. Used for simple `is in X% rollout` gates.",
-      "- **Gatekeeper stack** \u2014 an ordered array of `condition` and `rollout` sub-gates, evaluated top-to-bottom; first match wins. Used to express `internal-only \u222A 1% beta \u222A 50% public` in one gate. When `stack` is present it takes precedence over the flat fields.",
-      "",
-      "**Rules.** Each rule is `{ attr, op, value }`. Supported ops: `eq`, `neq`, `in`, `not_in`, `gt`, `gte`, `lt`, `lte`, `contains`, `regex`. Attribute names match the keys on the SDK evaluation context (e.g. `country`, `plan`, `email`).",
-      "",
-      "**Rollout basis points.** `rollout_pct` is in **basis points**, not percent. `0` = 0%, `100` = 1%, `5000` = 50%, `10000` = 100%. This allows sub-1% precision (e.g. `7` = 0.07%).",
-      "",
-      "**Lifecycle.** Create dark (`rollout_pct: 0`) \u2192 attach rules \u2192 ramp via PATCH \u2192 flip kill-switch via `disable`/`enable` \u2192 delete once retired. Deletion is blocked while a running experiment references the gate as a targeting gate."
-    ].join("\n")
-  },
-  schemas: {
-    create: gateCreateSchema,
-    update: gateUpdateSchema
-  },
-  /** Custom action endpoints beyond CRUD (POST <basePath>/:id/<action>). */
-  actions: [
-    { name: "enable", description: "Enable a gate" },
-    { name: "disable", 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.
-   */
-  endpoints: [
-    {
-      operationId: "listGates",
-      method: "GET",
-      path: "",
-      summary: "List feature gates",
-      description: "Returns a single page of gates ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.",
-      response: gateListResponseSchema,
-      examples: {
-        response: {
-          data: [
-            {
-              id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc",
-              name: "checkout_v2",
-              enabled: 1,
-              rolloutPct: 5e3,
-              rules: [
-                { attr: "country", op: "in", value: ["US", "CA", "GB"] },
-                { attr: "plan", op: "neq", value: "free" }
-              ],
-              salt: "9c1f4f1f2c0c4a5fa1c2b6d3e7c8e3a1",
-              title: "Checkout v2",
-              description: "New checkout flow. Pro users in US/CA/GB only.",
-              folder: "checkout",
-              groupName: "growth",
-              ownerEmail: "ana@example.com",
-              stack: null,
-              updatedAt: "2026-05-09T16:01:22.000Z"
-            }
-          ],
-          next_cursor: null
-        }
-      },
-      useCase: "Snapshot every gate in the project \u2014 for example to render an admin overview or to drive a CI check that asserts no gate is left at 100% in staging."
-    },
-    {
-      operationId: "createGate",
-      method: "POST",
-      path: "",
-      summary: "Create a feature gate",
-      description: [
-        "Creates a new gate. Default `enabled: true` at the supplied `rollout_pct` (`0` = fully dark).",
-        "",
-        "Only `name` is required. Request fields use snake_case (`owner_email`); the GET response returns camelCase (`ownerEmail`, `groupName`).",
-        "",
-        "Returns `409` if `name` already exists in the project (case-sensitive)."
-      ].join("\n"),
-      successStatus: 201,
-      request: gateCreateSchema,
-      response: gateCreateResponseSchema,
-      examples: {
-        requestExamples: {
-          minimal: {
-            summary: "Minimal \u2014 dark gate, name only",
-            description: "Smallest valid body. The gate is created `enabled: true` at `rollout_pct: 0`, with no rules. Ramp it later via PATCH.",
-            value: { name: "checkout_v2" }
-          },
-          targeted: {
-            summary: "Targeted rollout \u2014 rules + percentage",
-            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.",
-            value: {
-              name: "checkout_v2",
-              rollout_pct: 1e3,
-              rules: [
-                { attr: "country", op: "in", value: ["US", "CA", "GB"] },
-                { attr: "plan", op: "neq", value: "free" }
-              ],
-              title: "Checkout v2",
-              description: "New checkout flow. Pro users in US/CA/GB only.",
-              folder: "checkout",
-              group: "growth",
-              owner_email: "ana@example.com"
-            }
-          },
-          gatekeeperStack: {
-            summary: "Gatekeeper stack \u2014 internal \u222A beta \u222A public",
-            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`.",
-            value: {
-              name: "checkout_v2",
-              title: "Checkout v2",
-              owner_email: "ana@example.com",
-              stack: [
-                {
-                  id: "01HKJ0EMP",
-                  type: "condition",
-                  name: "Employees",
-                  pass: "any",
-                  rules: [{ attr: "email", op: "regex", value: "@acme\\.com$" }]
-                },
-                {
-                  id: "01HKJ0BETA",
-                  type: "condition",
-                  name: "Beta opt-in",
-                  pass: "all",
-                  rules: [{ attr: "beta_opt_in", op: "eq", value: true }]
-                },
-                {
-                  id: "01HKJ0PUB",
-                  type: "rollout",
-                  name: "Public",
-                  rolloutPct: 2500,
-                  bucketBy: "userID",
-                  locked: true
-                }
-              ]
-            }
-          },
-          disabledOnCreate: {
-            summary: "Disabled on create \u2014 provision then enable later",
-            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.",
-            value: { name: "checkout_v2", enabled: false, rollout_pct: 0 }
-          }
-        },
-        response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", name: "checkout_v2" }
-      },
-      useCase: [
-        '- **Dark create + ramp later** \u2014 `{ "name": "checkout_v2" }` at 0% rollout. Ramp via PATCH after deploy validation.',
-        "- **Targeted rollout** \u2014 supply `rules` to gate the caller (e.g. only `plan = pro` users) plus a `rollout_pct` to bucket within that audience.",
-        "- **Gatekeeper stack** \u2014 supply `stack` instead of `rules`/`rollout_pct` for `internal \u222A beta \u222A public` fall-through. Stack entries evaluated top-to-bottom; first match wins.",
-        "- **Dashboard metadata** \u2014 populate `title`, `description`, `folder`, `group`, `owner_email` so the admin UI is self-documenting from day one.",
-        "- **Disabled on create** \u2014 pre-provision with `enabled: false` for a future launch; flip on with `POST /{id}/enable` at go-live."
-      ].join("\n")
-    },
-    {
-      operationId: "updateGate",
-      method: "PATCH",
-      path: "/{id}",
-      summary: "Update a feature gate",
-      description: [
-        "Partial update \u2014 only supplied fields change. Array fields (`rules`, `stack`) **replace** wholesale; there is no merge or append.",
-        "",
-        "`name` and the gate id are immutable. The response carries only `{ id }` \u2014 re-fetch via `GET /api/admin/gates` for the new row."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque gate id (`gat_\u2026`)." },
-      request: gateUpdateSchema,
-      response: gateUpdateResponseSchema,
-      examples: {
-        requestExamples: {
-          rampRollout: {
-            summary: "Ramp rollout \u2014 0 \u2192 50%",
-            description: "Single-field patch. `5000` basis points = 50%.",
-            value: { rollout_pct: 5e3 }
-          },
-          killSwitch: {
-            summary: "Kill switch \u2014 disable the gate",
-            description: "Forces evaluation to `false` for every caller, regardless of rules or rollout. Same effect as `POST /{id}/disable` but composable with other patches.",
-            value: { enabled: false }
-          },
-          extendInRule: {
-            summary: "Add a value to an `in` rule",
-            description: "Array fields replace wholesale \u2014 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`.",
-            value: {
-              rules: [
-                { attr: "country", op: "in", value: ["US", "CA", "GB", "AU"] },
-                { attr: "plan", op: "neq", value: "free" }
-              ]
-            }
-          },
-          replaceStack: {
-            summary: "Replace gatekeeper stack",
-            description: 'Stack is replace-wholesale. Send the full new ordered list. Pass `"stack": null` to revert the gate to flat `rules` + `rollout_pct` evaluation.',
-            value: {
-              stack: [
-                {
-                  id: "01HKJ0EMP",
-                  type: "condition",
-                  name: "Employees",
-                  pass: "any",
-                  rules: [{ attr: "email", op: "regex", value: "@acme\\.com$" }]
-                },
-                {
-                  id: "01HKJ0PUB",
-                  type: "rollout",
-                  name: "Public",
-                  rolloutPct: 5e3,
-                  locked: true
-                }
-              ]
-            }
-          },
-          updateMetadata: {
-            summary: "Update dashboard metadata",
-            description: "Any subset of `title`, `description`, `folder`, `group`, `owner_email`. Snake-case in the request; the GET response returns camelCase (`groupName`, `ownerEmail`).",
-            value: {
-              title: "Checkout v2 (50%)",
-              description: "Bumped to 50% after passing canary. Added AU.",
-              folder: "checkout",
-              owner_email: "ana@example.com"
-            }
-          }
-        },
-        response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc" }
-      },
-      useCase: [
-        '- **Ramp rollout** \u2014 `{ "rollout_pct": 5000 }` for 50%. Basis points (0\u201310000); `100` = 1%.',
-        '- **Kill switch** \u2014 `{ "enabled": false }`. Forces evaluation to `false` for every caller regardless of rules/rollout. Re-enable with `POST /{id}/enable` or `{ "enabled": true }`.',
-        '- **Modify a rule\'s `in` set** \u2014 send the full new `rules` array. To add `\'GB\'` to `[\'US\',\'CA\']`: `{ "rules": [{ "attr": "country", "op": "in", "value": ["US","CA","GB"] }] }`. No per-rule patch endpoint.',
-        '- **Add targeting from scratch** \u2014 `{ "rules": [{ "attr": "email", "op": "regex", "value": "@acme\\\\.com$" }] }`.',
-        '- **Switch to gatekeeper stack** \u2014 send a non-null `stack`. To revert to flat eval, send `{ "stack": null }`.',
-        "- **Update metadata** \u2014 any subset of `title`, `description`, `folder`, `group`, `owner_email`."
-      ].join("\n")
-    },
-    {
-      operationId: "deleteGate",
-      method: "DELETE",
-      path: "/{id}",
-      summary: "Delete a feature gate",
-      description: "Soft-deletes the gate. Returns 409 if the gate is still referenced by a running experiment as a targeting gate \u2014 stop the experiment first.",
-      pathParams: { id: "Stable opaque gate id (`gat_\u2026`)." },
-      response: gateDeleteResponseSchema,
-      examples: { response: { ok: true } },
-      useCase: "Tear down a gate after a feature has fully shipped and the rollout flag is no longer needed."
-    },
-    {
-      operationId: "enableGate",
-      method: "POST",
-      path: "/{id}/enable",
-      summary: "Enable a gate",
-      description: "Sets `enabled: true`. The current `rollout_pct` is preserved.",
-      pathParams: { id: "Stable opaque gate id." },
-      response: gateToggleResponseSchema,
-      examples: { response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", enabled: true } },
-      useCase: "Re-enable a previously disabled gate without re-issuing a full update."
-    },
-    {
-      operationId: "disableGate",
-      method: "POST",
-      path: "/{id}/disable",
-      summary: "Disable a gate",
-      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.",
-      pathParams: { id: "Stable opaque gate id." },
-      response: gateToggleResponseSchema,
-      examples: { response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", enabled: false } },
-      useCase: "Flip a gate off in production without redeploying \u2014 the canonical kill-switch flow."
-    }
-  ]
-};
-export {
-  gatesClient,
-  gatesResource
-};