@shipeasy/openapi 1.0.0 → 1.2.0

package/dist/schemas/gates.d.ts

@@ -0,0 +1,304 @@
+import { z } from 'zod';
+
+declare const gateRuleSchema: 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";
+        semver_gt: "semver_gt";
+        semver_gte: "semver_gte";
+        semver_lt: "semver_lt";
+        semver_lte: "semver_lte";
+    }>;
+    value: z.ZodUnknown;
+}, z.core.$strip>;
+declare const gateNameSchema: z.ZodString;
+declare const stackedGateEntrySchema: 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";
+            semver_gt: "semver_gt";
+            semver_gte: "semver_gte";
+            semver_lt: "semver_lt";
+            semver_lte: "semver_lte";
+        }>;
+        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">;
+declare const gateMetadataPatchSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    group: z.ZodOptional<z.ZodString>;
+    owner_email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const gateCreateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    folder: z.ZodOptional<z.ZodNullable<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>;
+    rollout_percent: z.ZodOptional<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";
+            semver_gt: "semver_gt";
+            semver_gte: "semver_gte";
+            semver_lt: "semver_lt";
+            semver_lte: "semver_lte";
+        }>;
+        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";
+                semver_gt: "semver_gt";
+                semver_gte: "semver_gte";
+                semver_lt: "semver_lt";
+                semver_lte: "semver_lte";
+            }>;
+            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>;
+declare const gateUpdateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    group: z.ZodOptional<z.ZodString>;
+    owner_email: z.ZodOptional<z.ZodString>;
+    rollout_pct: z.ZodOptional<z.ZodNumber>;
+    rollout_percent: 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";
+            semver_gt: "semver_gt";
+            semver_gte: "semver_gte";
+            semver_lt: "semver_lt";
+            semver_lte: "semver_lte";
+        }>;
+        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";
+                semver_gt: "semver_gt";
+                semver_gte: "semver_gte";
+                semver_lt: "semver_lt";
+                semver_lte: "semver_lte";
+            }>;
+            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>;
+type GateCreateInput = z.input<typeof gateCreateSchema>;
+type GateUpdateInput = z.input<typeof gateUpdateSchema>;
+type StackedGateEntryInput = z.input<typeof stackedGateEntrySchema>;
+declare const gateResponseSchema: 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";
+            semver_gt: "semver_gt";
+            semver_gte: "semver_gte";
+            semver_lt: "semver_lt";
+            semver_lte: "semver_lte";
+        }>;
+        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";
+                semver_gt: "semver_gt";
+                semver_gte: "semver_gte";
+                semver_lt: "semver_lt";
+                semver_lte: "semver_lte";
+            }>;
+            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>;
+declare const gateCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const gateUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+declare const gateDeleteResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+declare const gateToggleResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+
+export { type GateCreateInput, type GateUpdateInput, type StackedGateEntryInput, gateCreateResponseSchema, gateCreateSchema, gateDeleteResponseSchema, gateMetadataPatchSchema, gateNameSchema, gateResponseSchema, gateRuleSchema, gateToggleResponseSchema, gateUpdateResponseSchema, gateUpdateSchema, stackedGateEntrySchema };

package/dist/schemas/gates.js

@@ -0,0 +1,172 @@
+// 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"
+  ]).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)."
+  ),
+  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`."
+  )
+}).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 stackedConditionSchema = z2.object({
+  id: z2.string().min(1).describe(
+    "Client-supplied stable id for the stack entry (used for React keys, audit diffs)."
+  ),
+  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."),
+  locked: z2.boolean().optional().describe("If `true`, dashboard hides edit controls (e.g. the trailing public-floor entry).")
+}).describe(
+  "Rule-based sub-gate. When matched, evaluation short-circuits and the gate returns `true` for the current caller."
+);
+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."
+  ),
+  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."
+);
+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()
+});
+export {
+  gateCreateResponseSchema,
+  gateCreateSchema,
+  gateDeleteResponseSchema,
+  gateMetadataPatchSchema,
+  gateNameSchema,
+  gateResponseSchema,
+  gateRuleSchema,
+  gateToggleResponseSchema,
+  gateUpdateResponseSchema,
+  gateUpdateSchema,
+  stackedGateEntrySchema
+};

package/dist/schemas/index.d.ts

@@ -0,0 +1,11 @@
+export { CONFIG_ENVS, CONFIG_KINDS, ConfigEnv, ConfigKind } from './constants.js';
+export { CursorParts, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE, Page, PageQuery, decodeCursor, encodeCursor, pageQuerySchema } from './pagination.js';
+export { FolderInput, folderSchema } from './folder.js';
+export { metricNameSchema } from './metric-name.js';
+export { ConfigCreateInput, ConfigDraftUpsertInput, ConfigPublishInput, ConfigSchemaUpdateInput, ConfigUpdateInput, JsonSchemaInput, configActivityEntrySchema, configActivityResponseSchema, configCreateResponseSchema, configCreateSchema, configDeleteResponseSchema, configDraftDiscardResponseSchema, configDraftSaveResponseSchema, configDraftUpsertSchema, configEnvSchema, configKindSchema, configNameSchema, configPublishResponseSchema, configPublishSchema, configResponseSchema, configSchemaUpdateSchema, configUpdateResponseSchema, configUpdateSchema, jsonSchemaSchema } from './configs.js';
+export { GateCreateInput, GateUpdateInput, StackedGateEntryInput, gateCreateResponseSchema, gateCreateSchema, gateDeleteResponseSchema, gateMetadataPatchSchema, gateNameSchema, gateResponseSchema, gateRuleSchema, gateToggleResponseSchema, gateUpdateResponseSchema, gateUpdateSchema, stackedGateEntrySchema } from './gates.js';
+export { KillswitchCreateInput, KillswitchSwitchSetInput, KillswitchSwitchUnsetInput, KillswitchUpdateInput, KillswitchValue, KillswitchValueSetInput, SWITCH_KEY_RE, killswitchCreateResponseSchema, killswitchCreateSchema, killswitchDeleteResponseSchema, killswitchResponseSchema, killswitchSwitchSetResponseSchema, killswitchSwitchSetSchema, killswitchSwitchUnsetResponseSchema, killswitchSwitchUnsetSchema, killswitchUpdateResponseSchema, killswitchUpdateSchema, killswitchValueSchema, killswitchValueSetSchema, switchKeySchema } from './killswitches.js';
+export { UniverseCreateInput, UniverseUpdateInput, holdoutRangeSchema, universeCreateResponseSchema, universeCreateSchema, universeDeleteResponseSchema, universeNameSchema, universeResponseSchema, universeUpdateResponseSchema, universeUpdateSchema } from './universes.js';
+export { ExperimentCreateInput, ExperimentInlineMetric, ExperimentUpdateInput, bucketBySchema, experimentCreateResponseSchema, experimentCreateSchema, experimentDeleteResponseSchema, experimentGroupSchema, experimentInlineMetricSchema, experimentMetricsResponseSchema, experimentMetricsUpdateSchema, experimentNameSchema, experimentReanalyzeResponseSchema, experimentResponseSchema, experimentResultsResponseSchema, experimentStatusResponseSchema, experimentStatusUpdateSchema, experimentTimeseriesResponseSchema, experimentUpdateResponseSchema, experimentUpdateSchema, paramSchemaSchema } from './experiments.js';
+export { ALERT_COMPARATORS, ALERT_SEVERITIES, AlertRuleCreate, AlertRuleUpdate, alertRuleCreateSchema, alertRuleUpdateSchema } from './alert-rules.js';
+import 'zod';