@shipeasy/openapi 1.0.0 → 1.1.0

package/dist/schemas/killswitches.d.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+
+/** A switch key is a single lowercase segment (no dots). */
+declare const SWITCH_KEY_RE: RegExp;
+declare const switchKeySchema: z.ZodString;
+/** The fixed runtime payload delivered to clients:
+ *
+ *   { value: <bool>, switches?: { <switch_key>: <bool>, … } }
+ *
+ * `switches` is optional. When present, an entry takes precedence over `value`
+ * for that specific switch_key on the client. */
+declare const killswitchValueSchema: z.ZodObject<{
+    value: z.ZodBoolean;
+    switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.core.$strip>;
+type KillswitchValue = z.infer<typeof killswitchValueSchema>;
+declare const killswitchCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    value: z.ZodOptional<z.ZodBoolean>;
+    switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.core.$strip>;
+declare const killswitchUpdateSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    value: z.ZodOptional<z.ZodBoolean>;
+    switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+}, z.core.$strip>;
+/** PUT one switch entry on one env. */
+declare const killswitchSwitchSetSchema: z.ZodObject<{
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    switchKey: z.ZodString;
+    value: z.ZodBoolean;
+}, z.core.$strip>;
+/** PATCH the flat default value for one env (dashboard quick-toggle). */
+declare const killswitchValueSetSchema: z.ZodObject<{
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    value: z.ZodBoolean;
+}, z.core.$strip>;
+/** DELETE one switch entry on one env. */
+declare const killswitchSwitchUnsetSchema: z.ZodObject<{
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    switchKey: z.ZodString;
+}, z.core.$strip>;
+declare const killswitchResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+    envs: z.ZodRecord<z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>, z.ZodObject<{
+        value: z.ZodBoolean;
+        switches: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        version: z.ZodNumber;
+        publishedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const killswitchCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const killswitchUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+declare const killswitchDeleteResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+declare const killswitchSwitchSetResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    switchKey: z.ZodString;
+    value: z.ZodBoolean;
+}, z.core.$strip>;
+declare const killswitchSwitchUnsetResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    switchKey: z.ZodString;
+    removed: z.ZodBoolean;
+}, z.core.$strip>;
+type KillswitchCreateInput = z.infer<typeof killswitchCreateSchema>;
+type KillswitchUpdateInput = z.infer<typeof killswitchUpdateSchema>;
+type KillswitchSwitchSetInput = z.infer<typeof killswitchSwitchSetSchema>;
+type KillswitchValueSetInput = z.infer<typeof killswitchValueSetSchema>;
+type KillswitchSwitchUnsetInput = z.infer<typeof killswitchSwitchUnsetSchema>;
+
+export { type KillswitchCreateInput, type KillswitchSwitchSetInput, type KillswitchSwitchUnsetInput, type KillswitchUpdateInput, type KillswitchValue, type KillswitchValueSetInput, SWITCH_KEY_RE, killswitchCreateResponseSchema, killswitchCreateSchema, killswitchDeleteResponseSchema, killswitchResponseSchema, killswitchSwitchSetResponseSchema, killswitchSwitchSetSchema, killswitchSwitchUnsetResponseSchema, killswitchSwitchUnsetSchema, killswitchUpdateResponseSchema, killswitchUpdateSchema, killswitchValueSchema, killswitchValueSetSchema, switchKeySchema };

package/dist/schemas/killswitches.js

@@ -0,0 +1,226 @@
+// src/schemas/killswitches.ts
+import { z as z3 } from "zod";
+
+// src/schemas/configs.ts
+import { z as z2 } from "zod";
+
+// src/schemas/constants.ts
+var CONFIG_ENVS = ["dev", "staging", "prod"];
+var CONFIG_KINDS = ["config", "killswitch"];
+
+// 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/configs.ts
+var SEGMENT = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
+var RESERVED_FOLDER = "_default";
+var configNameSchema = z2.string().max(128).refine(
+  (s) => {
+    const parts = s.split(".");
+    if (parts.length !== 2) return false;
+    return parts.every((p, i) => p === RESERVED_FOLDER && i === 0 ? true : SEGMENT.test(p));
+  },
+  {
+    message: "Must be `folder.name` \u2014 exactly two lowercase segments separated by a dot (e.g. `pricing.tiers`)."
+  }
+).describe(
+  "Stable config key in `folder.name` form (two lowercase segments separated by a dot, e.g. `pricing.tiers`). Used by SDKs as `Shipeasy.getConfig('<name>')`. Immutable after create."
+);
+var configKindSchema = z2.enum(CONFIG_KINDS);
+var configEnvSchema = z2.enum(CONFIG_ENVS).describe("Target environment. One of the project's configured envs (`dev`, `stage`, `prod`).");
+var jsonSchemaSchema = z2.record(z2.string(), z2.unknown()).refine((s) => s.type === "object", { message: "Top-level schema type must be 'object'" }).describe(
+  "JSON Schema (draft 2020-12) describing the shape of the config value. Top-level `type` must be `'object'`; every published value is validated against this schema."
+);
+var initialValuesSchema = z2.union([z2.unknown(), z2.record(configEnvSchema, z2.unknown())]).describe(
+  "Initial config value. Either a single JSON object applied to every env, or a `{ env: value }` map seeding per-env values. Must match `schema`. Defaults to `{}` on every env when omitted."
+);
+var configCreateSchema = z2.object({
+  name: configNameSchema,
+  description: z2.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  folder: folderSchema,
+  schema: jsonSchemaSchema,
+  value: initialValuesSchema.optional()
+}).describe("Body for `POST /api/admin/configs`. `name` + `schema` required.");
+var configUpdateSchema = z2.object({
+  schema: jsonSchemaSchema.optional().describe(
+    "Replacement schema. When supplied, the new schema is validated against every published value before it lands."
+  ),
+  value: z2.unknown().optional().describe(
+    "Flat value applied to **every** env. Publishes a new version per env. To target one env, use `PUT /{id}/drafts` then `POST /{id}/publish`."
+  ),
+  folder: folderSchema
+}).describe(
+  "Body for `PATCH /api/admin/configs/{id}`. Partial \u2014 only supplied fields change. `value` republishes on every env."
+);
+var configSchemaUpdateSchema = z2.object({ schema: jsonSchemaSchema }).describe("Schema-only update. Does not bump value versions or rebuild KV.");
+var configDraftUpsertSchema = z2.object({
+  env: configEnvSchema,
+  value: z2.unknown().describe("Draft value to stage on `env`. Validated against the config's current schema.")
+}).describe(
+  "Body for `PUT /api/admin/configs/{id}/drafts`. Stages a value for a single env without publishing."
+);
+var configPublishSchema = z2.object({ env: configEnvSchema }).describe(
+  "Body for `POST /api/admin/configs/{id}/publish` and `DELETE /api/admin/configs/{id}/drafts`. Names the target env."
+);
+var configEnvPublishedSchema = z2.object({
+  version: z2.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z2.string().describe("ISO-8601 publish timestamp."),
+  publishedBy: z2.string().describe("Email/id of the actor who published this version.")
+});
+var configDraftSummarySchema = z2.object({
+  updatedAt: z2.string().describe("ISO-8601 last-edit timestamp on the draft."),
+  authorEmail: z2.string().describe("Email/id of the actor who last edited the draft."),
+  baseVersion: z2.number().int().describe("Published version the draft was forked from.")
+});
+var configResponseSchema = z2.object({
+  id: z2.string().describe("Stable opaque config id (`cfg_\u2026`)."),
+  name: configNameSchema,
+  description: z2.string().nullable(),
+  schema: jsonSchemaSchema,
+  updatedAt: z2.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z2.record(configEnvSchema, configEnvPublishedSchema).describe("Per-env latest published version metadata."),
+  drafts: z2.record(configEnvSchema, configDraftSummarySchema).describe("Per-env active drafts (if any)."),
+  values: z2.record(configEnvSchema, z2.unknown()).optional().describe("Per-env latest published values (only returned by `GET /{id}`, not list)."),
+  draftValues: z2.record(configEnvSchema, z2.unknown()).optional().describe("Per-env draft values (only returned by `GET /{id}`).")
+});
+var configCreateResponseSchema = z2.object({
+  id: z2.string().describe("Newly assigned config id."),
+  name: configNameSchema
+});
+var configUpdateResponseSchema = z2.object({
+  id: z2.string().describe("Config id that was updated.")
+});
+var configDeleteResponseSchema = z2.object({ ok: z2.literal(true) });
+var configDraftSaveResponseSchema = z2.object({
+  id: z2.string(),
+  env: configEnvSchema,
+  baseVersion: z2.number().int().describe("Published version the draft is based on."),
+  updatedAt: z2.string()
+});
+var configDraftDiscardResponseSchema = z2.object({ ok: z2.literal(true) });
+var configPublishResponseSchema = z2.object({
+  id: z2.string(),
+  env: configEnvSchema,
+  version: z2.number().int().describe("Newly published version on `env`.")
+});
+var configActivityEntrySchema = z2.object({
+  id: z2.string(),
+  action: z2.string().describe("Audit action (e.g. `config.create`, `config.publish`)."),
+  actorEmail: z2.string(),
+  actorType: z2.enum(["user", "cli", "system"]),
+  payload: z2.unknown().nullable(),
+  createdAt: z2.string().describe("ISO-8601 timestamp.")
+});
+var configActivityResponseSchema = z2.array(configActivityEntrySchema).describe("Recent audit rows for one config, newest first.");
+
+// src/schemas/killswitches.ts
+var SWITCH_KEY_RE = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
+var switchKeySchema = z3.string().max(64).regex(SWITCH_KEY_RE, {
+  message: "Switch keys must be lowercase, no dots."
+}).describe(
+  "Single-segment switch key (lowercase letters, digits, `_`/`-`; no dots). Used as the nested switch entry inside a killswitch's `switches` map."
+);
+var killswitchValueSchema = z3.object({
+  value: z3.boolean().describe(
+    "Default boolean delivered when no `switches` entry matches the caller's switch key."
+  ),
+  switches: z3.record(switchKeySchema, z3.boolean()).optional().describe(
+    "Per-switch overrides. When present, a matching key takes precedence over `value` on the client."
+  )
+}).describe("Runtime killswitch payload returned to SDKs.");
+var killswitchCreateSchema = z3.object({
+  name: configNameSchema.describe(
+    "Stable killswitch key in `folder.name` form (two lowercase segments separated by a dot \u2014 e.g. `payments.checkout`). Immutable after create."
+  ),
+  description: z3.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  folder: folderSchema,
+  value: z3.boolean().optional().describe(
+    "Default value applied to every env at creation. Defaults to `false`. Use `true` to ship the killswitch pre-tripped."
+  ),
+  switches: z3.record(switchKeySchema, z3.boolean()).optional().describe(
+    "Initial per-switch overrides applied to every env. Empty/omitted leaves the killswitch with only the flat `value`."
+  )
+}).describe("Body for `POST /api/admin/killswitches`. Only `name` is required.");
+var killswitchUpdateSchema = z3.object({
+  description: z3.string().max(512).nullish().describe("New description, or `null` to clear it. Max 512 chars."),
+  folder: folderSchema,
+  value: z3.boolean().optional().describe(
+    "Flat value applied to every env. Publishes a new version per env when set. Omit to leave values unchanged."
+  ),
+  switches: z3.record(switchKeySchema, z3.boolean()).optional().describe(
+    "Replace the switches map wholesale on every env. To edit a single entry on a single env use `PUT /{id}/switch` instead."
+  )
+}).describe(
+  "Body for `PATCH /api/admin/killswitches/{id}`. Partial \u2014 only supplied fields change. `switches` replaces wholesale (no merge)."
+);
+var killswitchSwitchSetSchema = z3.object({
+  env: configEnvSchema.describe("Target environment (`dev`/`stage`/`prod`)."),
+  switchKey: switchKeySchema.describe("Switch key to set."),
+  value: z3.boolean().describe("New boolean value for this `switchKey` on this `env`.")
+}).describe(
+  "Body for `PUT /api/admin/killswitches/{id}/switch`. Sets or updates one switch entry on one env."
+);
+var killswitchValueSetSchema = z3.object({
+  env: configEnvSchema.describe("Target environment whose flat default flips."),
+  value: z3.boolean().describe("New flat default for this env. Existing switches carry forward unchanged.")
+}).describe(
+  "Body for the killswitch quick-toggle. Sets the flat `value` on one env without touching its switches."
+);
+var killswitchSwitchUnsetSchema = z3.object({
+  env: configEnvSchema.describe("Target environment."),
+  switchKey: switchKeySchema.describe("Switch key to remove.")
+}).describe(
+  "Body for `DELETE /api/admin/killswitches/{id}/switch`. Removes one switch entry from one env."
+);
+var killswitchEnvEntrySchema = z3.object({
+  value: z3.boolean().describe("Flat boolean published for this env."),
+  switches: z3.record(switchKeySchema, z3.boolean()).optional(),
+  version: z3.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z3.string().describe("ISO-8601 publish timestamp for this version.")
+});
+var killswitchResponseSchema = z3.object({
+  id: z3.string().describe("Stable opaque killswitch id."),
+  name: configNameSchema,
+  description: z3.string().nullable().describe("Free-form description or `null`."),
+  updatedAt: z3.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z3.record(configEnvSchema, killswitchEnvEntrySchema).describe("Per-env latest value, switches, version, and publish timestamp.")
+});
+var killswitchCreateResponseSchema = z3.object({
+  id: z3.string().describe("Newly assigned killswitch id."),
+  name: configNameSchema
+});
+var killswitchUpdateResponseSchema = z3.object({
+  id: z3.string().describe("Killswitch id that was updated.")
+});
+var killswitchDeleteResponseSchema = z3.object({ ok: z3.literal(true) });
+var killswitchSwitchSetResponseSchema = z3.object({
+  id: z3.string(),
+  env: configEnvSchema,
+  switchKey: switchKeySchema,
+  value: z3.boolean()
+});
+var killswitchSwitchUnsetResponseSchema = z3.object({
+  id: z3.string(),
+  env: configEnvSchema,
+  switchKey: switchKeySchema,
+  removed: z3.boolean().describe("`true` if the entry existed and was removed, `false` if no-op.")
+});
+export {
+  SWITCH_KEY_RE,
+  killswitchCreateResponseSchema,
+  killswitchCreateSchema,
+  killswitchDeleteResponseSchema,
+  killswitchResponseSchema,
+  killswitchSwitchSetResponseSchema,
+  killswitchSwitchSetSchema,
+  killswitchSwitchUnsetResponseSchema,
+  killswitchSwitchUnsetSchema,
+  killswitchUpdateResponseSchema,
+  killswitchUpdateSchema,
+  killswitchValueSchema,
+  killswitchValueSetSchema,
+  switchKeySchema
+};

package/dist/schemas/metric-name.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+declare const metricNameSchema: z.ZodString;
+
+export { metricNameSchema };

package/dist/schemas/metric-name.js

@@ -0,0 +1,6 @@
+// src/schemas/metric-name.ts
+import { z } from "zod";
+var metricNameSchema = z.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128);
+export {
+  metricNameSchema
+};

package/dist/schemas/pagination.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+
+declare const DEFAULT_PAGE_SIZE = 100;
+declare const MAX_PAGE_SIZE = 500;
+/**
+ * Query params for any paginated list endpoint. `cursor` is opaque to
+ * consumers; servers encode/decode via {@link encodeCursor}/{@link decodeCursor}.
+ */
+declare const pageQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PageQuery = z.infer<typeof pageQuerySchema>;
+/** Standard envelope every paginated list endpoint returns. */
+interface Page<T> {
+    data: T[];
+    next_cursor: string | null;
+}
+/**
+ * Cursor encodes the `(ts, id)` tuple of the last row from the previous page.
+ * `ts` is whichever ISO-8601 timestamp column the resource sorts by — most
+ * resources use `updated_at`, but ones that lack it (universes, sdk_keys) use
+ * `created_at`. Sort order is always `ORDER BY <ts> DESC, id DESC`; keyset
+ * comparison is `(ts, id) < (cursor.ts, cursor.id)`. ISO-8601 text sorts
+ * lexicographically, so string comparison is correct.
+ *
+ * The cursor is opaque to SDK consumers — only the server (which encodes) and
+ * the client transport (which round-trips it) need to know the structure.
+ */
+interface CursorParts {
+    ts: string;
+    id: string;
+}
+declare function encodeCursor(parts: CursorParts): string;
+declare function decodeCursor(cursor: string): CursorParts;
+
+export { type CursorParts, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE, type Page, type PageQuery, decodeCursor, encodeCursor, pageQuerySchema };

package/dist/schemas/pagination.js

@@ -0,0 +1,44 @@
+// src/schemas/pagination.ts
+import { z } from "zod";
+var DEFAULT_PAGE_SIZE = 100;
+var MAX_PAGE_SIZE = 500;
+var pageQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(MAX_PAGE_SIZE).default(DEFAULT_PAGE_SIZE),
+  cursor: z.string().min(1).optional()
+});
+var SEP = "|";
+function encodeCursor(parts) {
+  if (parts.ts.includes(SEP)) {
+    throw new Error(`pagination: ts must not contain '${SEP}'`);
+  }
+  return base64UrlEncode(`${parts.ts}${SEP}${parts.id}`);
+}
+function decodeCursor(cursor) {
+  let raw;
+  try {
+    raw = base64UrlDecode(cursor);
+  } catch {
+    throw new Error("pagination: cursor is not valid base64url");
+  }
+  const sep = raw.indexOf(SEP);
+  if (sep < 0) throw new Error("pagination: cursor missing separator");
+  const ts = raw.slice(0, sep);
+  const id = raw.slice(sep + 1);
+  if (!ts || !id) throw new Error("pagination: cursor parts empty");
+  return { ts, id };
+}
+function base64UrlEncode(s) {
+  const b64 = btoa(s);
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(s) {
+  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
+  return atob(s.replace(/-/g, "+").replace(/_/g, "/") + pad);
+}
+export {
+  DEFAULT_PAGE_SIZE,
+  MAX_PAGE_SIZE,
+  decodeCursor,
+  encodeCursor,
+  pageQuerySchema
+};

package/dist/schemas/universes.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+
+declare const universeNameSchema: z.ZodString;
+declare const holdoutRangeSchema: z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+declare const universeCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unit_type: z.ZodDefault<z.ZodString>;
+    holdout_range: z.ZodDefault<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+}, z.core.$strip>;
+declare const universeUpdateSchema: z.ZodObject<{
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    holdout_range: z.ZodOptional<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+}, z.core.$strip>;
+declare const universeResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    unitType: z.ZodString;
+    holdoutRange: z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+declare const universeCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const universeUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+declare const universeDeleteResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+type UniverseCreateInput = z.infer<typeof universeCreateSchema>;
+type UniverseUpdateInput = z.infer<typeof universeUpdateSchema>;
+
+export { type UniverseCreateInput, type UniverseUpdateInput, holdoutRangeSchema, universeCreateResponseSchema, universeCreateSchema, universeDeleteResponseSchema, universeNameSchema, universeResponseSchema, universeUpdateResponseSchema, universeUpdateSchema };

package/dist/schemas/universes.js

@@ -0,0 +1,55 @@
+// src/schemas/universes.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/universes.ts
+var universeNameSchema = z2.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128).describe(
+  "Stable universe key. Single segment or `folder.name`. Lowercase letters, digits, `_` or `-`; max 128 chars. Immutable after create."
+);
+var holdoutRangeSchema = z2.tuple([z2.number().int().min(0).max(9999), z2.number().int().min(0).max(9999)]).refine(([lo, hi]) => lo <= hi, "lo must be <= hi").nullable().describe(
+  "Inclusive `[lo, hi]` bucket range (0\u20139999) reserved as the **holdout** \u2014 callers hashed into this slice are excluded from every experiment in the universe. `null` disables the holdout. Pro plan or higher required."
+);
+var universeCreateSchema = z2.object({
+  name: universeNameSchema,
+  folder: folderSchema,
+  unit_type: z2.string().default("user_id").describe(
+    "Unit of randomisation. Typically `user_id`. Use `account_id` to keep whole accounts in the same group across an experiment."
+  ),
+  holdout_range: holdoutRangeSchema.default(null)
+}).describe("Body for `POST /api/admin/universes`. Only `name` is required.");
+var universeUpdateSchema = z2.object({
+  folder: folderSchema,
+  holdout_range: holdoutRangeSchema.optional()
+}).describe(
+  "Body for `PATCH /api/admin/universes/{id}`. Only `holdout_range` is mutable \u2014 name and unit_type are immutable after create."
+);
+var universeResponseSchema = z2.object({
+  id: z2.string().describe("Stable opaque universe id."),
+  name: universeNameSchema,
+  unitType: z2.string().describe("Unit of randomisation. Snake-case in request (`unit_type`), camelCase in response."),
+  holdoutRange: z2.tuple([z2.number(), z2.number()]).nullable().describe("Reserved holdout bucket range, or `null` if none."),
+  createdAt: z2.string().describe("ISO-8601 timestamp of creation.")
+});
+var universeCreateResponseSchema = z2.object({
+  id: z2.string().describe("Newly assigned universe id."),
+  name: universeNameSchema
+});
+var universeUpdateResponseSchema = z2.object({
+  id: z2.string().describe("Universe id that was updated.")
+});
+var universeDeleteResponseSchema = z2.object({ ok: z2.literal(true) });
+export {
+  holdoutRangeSchema,
+  universeCreateResponseSchema,
+  universeCreateSchema,
+  universeDeleteResponseSchema,
+  universeNameSchema,
+  universeResponseSchema,
+  universeUpdateResponseSchema,
+  universeUpdateSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipeasy/openapi",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Shipeasy admin OpenAPI spec + typed client. Single source of truth for endpoint paths, request/response shapes, and the resource registry consumed by @shipeasy/cli and @shipeasy/mcp.",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,6 +22,10 @@
       "types": "./dist/resources/*.d.ts",
       "default": "./dist/resources/*.js"
     },
+    "./schemas/*": {
+      "types": "./dist/schemas/*.d.ts",
+      "default": "./dist/schemas/*.js"
+    },
     "./transport": {
       "types": "./dist/transport.d.ts",
       "default": "./dist/transport.js"
@@ -35,6 +39,12 @@
     "dist/",
     "openapi.json"
   ],
+  "scripts": {
+    "build": "tsup",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "emit-openapi": "tsx scripts/emit-spec.ts"
+  },
   "dependencies": {
     "zod": "^4.0.0"
   },
@@ -43,16 +53,9 @@
     "tsup": "^8.3.0",
     "tsx": "^4.21.0",
     "typescript": "^5.7.4",
-    "vitest": "^2.1.0",
-    "@shipeasy/core": "1.0.0"
+    "vitest": "^2.1.0"
   },
   "engines": {
     "node": ">=20"
-  },
-  "scripts": {
-    "build": "tsup",
-    "type-check": "tsc --noEmit",
-    "test": "vitest run",
-    "emit-openapi": "tsx scripts/emit-spec.ts"
   }
-}
+}