@shipeasy/openapi 1.0.0 → 1.2.0

package/dist/resources/universes.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
-import { UniverseCreateInput, UniverseUpdateInput } from '@shipeasy/core/schemas/universes';
-export { UniverseCreateInput, UniverseUpdateInput } from '@shipeasy/core/schemas/universes';
-import { PageQuery, Page } from '@shipeasy/core/pagination';
+import { UniverseCreateInput, UniverseUpdateInput } from '../schemas/universes.js';
+import { PageQuery, Page } from '../schemas/pagination.js';
 import { Transport } from '../transport.js';
 
 interface Universe {
@@ -36,10 +35,12 @@ declare const universesResource: {
     readonly schemas: {
         readonly create: 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>;
         readonly update: 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>;
     };
@@ -82,6 +83,7 @@ declare const universesResource: {
         readonly successStatus: 201;
         readonly request: 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>;
@@ -131,6 +133,7 @@ declare const universesResource: {
             readonly id: "Stable opaque universe id (`uni_…`).";
         };
         readonly request: 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>;
         readonly response: z.ZodObject<{
@@ -179,4 +182,4 @@ declare const universesResource: {
     }];
 };
 
-export { type Universe, type UniversesClient, universesClient, universesResource };
+export { type Universe, UniverseCreateInput, UniverseUpdateInput, type UniversesClient, universesClient, universesResource };

package/dist/resources/universes.js

@@ -1,41 +1,51 @@
 // src/resources/universes.ts
+import { z as z3 } from "zod";
+
+// src/schemas/universes.ts
 import { z as z2 } from "zod";
 
-// ../core/src/schemas/universes.ts
+// src/schemas/folder.ts
 import { z } from "zod";
-var universeNameSchema = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/).describe(
-  "Stable universe key referenced by experiments via `universe: '<name>'`. Lowercase letters, digits, `_` or `-`, max 64 chars. Immutable after create."
+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 = z.tuple([z.number().int().min(0).max(9999), z.number().int().min(0).max(9999)]).refine(([lo, hi]) => lo <= hi, "lo must be <= hi").nullable().describe(
+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 = z.object({
+var universeCreateSchema = z2.object({
   name: universeNameSchema,
-  unit_type: z.string().default("user_id").describe(
+  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 = z.object({
+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 = z.object({
-  id: z.string().describe("Stable opaque universe id."),
+var universeResponseSchema = z2.object({
+  id: z2.string().describe("Stable opaque universe id."),
   name: universeNameSchema,
-  unitType: z.string().describe("Unit of randomisation. Snake-case in request (`unit_type`), camelCase in response."),
-  holdoutRange: z.tuple([z.number(), z.number()]).nullable().describe("Reserved holdout bucket range, or `null` if none."),
-  createdAt: z.string().describe("ISO-8601 timestamp of creation.")
+  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 = z.object({
-  id: z.string().describe("Newly assigned universe id."),
+var universeCreateResponseSchema = z2.object({
+  id: z2.string().describe("Newly assigned universe id."),
   name: universeNameSchema
 });
-var universeUpdateResponseSchema = z.object({
-  id: z.string().describe("Universe id that was updated.")
+var universeUpdateResponseSchema = z2.object({
+  id: z2.string().describe("Universe id that was updated.")
 });
-var universeDeleteResponseSchema = z.object({ ok: z.literal(true) });
+var universeDeleteResponseSchema = z2.object({ ok: z2.literal(true) });
 
 // src/transport.ts
 var ApiError = class extends Error {
@@ -48,9 +58,9 @@ var ApiError = class extends Error {
 };
 
 // src/resources/universes.ts
-var universeListResponseSchema = z2.object({
-  data: z2.array(universeResponseSchema),
-  next_cursor: z2.string().nullable()
+var universeListResponseSchema = z3.object({
+  data: z3.array(universeResponseSchema),
+  next_cursor: z3.string().nullable()
 });
 var BASE = "/api/admin/universes";
 function universesClient(t) {

package/dist/schemas/alert-rules.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+declare const ALERT_COMPARATORS: readonly ["gt", "gte", "lt", "lte"];
+declare const ALERT_SEVERITIES: readonly ["danger", "warn", "info"];
+declare const alertRuleCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    metricId: z.ZodString;
+    comparator: z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+    }>;
+    threshold: z.ZodNumber;
+    windowHours: z.ZodDefault<z.ZodNumber>;
+    severity: z.ZodDefault<z.ZodEnum<{
+        danger: "danger";
+        warn: "warn";
+        info: "info";
+    }>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const alertRuleUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    comparator: z.ZodOptional<z.ZodEnum<{
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+    }>>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    windowHours: z.ZodOptional<z.ZodNumber>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        danger: "danger";
+        warn: "warn";
+        info: "info";
+    }>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type AlertRuleCreate = z.infer<typeof alertRuleCreateSchema>;
+type AlertRuleUpdate = z.infer<typeof alertRuleUpdateSchema>;
+
+export { ALERT_COMPARATORS, ALERT_SEVERITIES, type AlertRuleCreate, type AlertRuleUpdate, alertRuleCreateSchema, alertRuleUpdateSchema };

package/dist/schemas/alert-rules.js

@@ -0,0 +1,27 @@
+// src/schemas/alert-rules.ts
+import { z } from "zod";
+var ALERT_COMPARATORS = ["gt", "gte", "lt", "lte"];
+var ALERT_SEVERITIES = ["danger", "warn", "info"];
+var alertRuleCreateSchema = z.object({
+  name: z.string().min(1).max(120).describe("Human label for the rule, shown on the alert and the rules list."),
+  metricId: z.string().min(1).describe("Id of the metric to evaluate."),
+  comparator: z.enum(ALERT_COMPARATORS).describe("How the metric value is compared to the threshold (gt/gte/lt/lte)."),
+  threshold: z.number().finite().describe("Threshold the metric value is compared against."),
+  windowHours: z.number().int().min(1).max(720).default(24).describe("Lookback window (hours) the metric is aggregated over. 1\u2013720."),
+  severity: z.enum(ALERT_SEVERITIES).default("warn").describe("Severity of the raised alert."),
+  enabled: z.boolean().default(true).describe("Whether the rule is evaluated by the cron.")
+}).strict();
+var alertRuleUpdateSchema = z.object({
+  name: z.string().min(1).max(120),
+  comparator: z.enum(ALERT_COMPARATORS),
+  threshold: z.number().finite(),
+  windowHours: z.number().int().min(1).max(720),
+  severity: z.enum(ALERT_SEVERITIES),
+  enabled: z.boolean()
+}).partial().strict();
+export {
+  ALERT_COMPARATORS,
+  ALERT_SEVERITIES,
+  alertRuleCreateSchema,
+  alertRuleUpdateSchema
+};

package/dist/schemas/configs.d.ts

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+
+/** Names are exactly two segments — `<folder>.<name>` — so the dashboard can
+ *  group rows by folder. `_default` is reserved for the migration that lifts
+ *  legacy single-segment names and is the only segment allowed to start with
+ *  an underscore. */
+declare const configNameSchema: z.ZodString;
+declare const configKindSchema: z.ZodEnum<{
+    config: "config";
+    killswitch: "killswitch";
+}>;
+declare const configEnvSchema: z.ZodEnum<{
+    dev: "dev";
+    staging: "staging";
+    prod: "prod";
+}>;
+/** JSON Schema describing the shape of a config value.
+ * Configs are object-only; the top-level `type` must be `"object"`. */
+declare const jsonSchemaSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+type JsonSchemaInput = z.infer<typeof jsonSchemaSchema>;
+declare const configCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnknown, z.ZodRecord<z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>, z.ZodUnknown>]>>;
+}, z.core.$strip>;
+/** Flat update — accepts an optional new schema and/or a flat value applied to all envs. */
+declare const configUpdateSchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    value: z.ZodOptional<z.ZodUnknown>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** Schema-only update — does not bump value versions or rebuild KV. */
+declare const configSchemaUpdateSchema: z.ZodObject<{
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const configDraftUpsertSchema: z.ZodObject<{
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    value: z.ZodUnknown;
+}, z.core.$strip>;
+declare const configPublishSchema: z.ZodObject<{
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+}, z.core.$strip>;
+declare const configResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    updatedAt: z.ZodString;
+    envs: z.ZodRecord<z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>, z.ZodObject<{
+        version: z.ZodNumber;
+        publishedAt: z.ZodString;
+        publishedBy: z.ZodString;
+    }, z.core.$strip>>;
+    drafts: z.ZodRecord<z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>, z.ZodObject<{
+        updatedAt: z.ZodString;
+        authorEmail: z.ZodString;
+        baseVersion: z.ZodNumber;
+    }, z.core.$strip>>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>, z.ZodUnknown>>;
+    draftValues: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const configCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const configUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+declare const configDeleteResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+declare const configDraftSaveResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    baseVersion: z.ZodNumber;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+declare const configDraftDiscardResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+declare const configPublishResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    env: z.ZodEnum<{
+        dev: "dev";
+        staging: "staging";
+        prod: "prod";
+    }>;
+    version: z.ZodNumber;
+}, z.core.$strip>;
+declare const configActivityEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    actorEmail: z.ZodString;
+    actorType: z.ZodEnum<{
+        user: "user";
+        cli: "cli";
+        system: "system";
+    }>;
+    payload: z.ZodNullable<z.ZodUnknown>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+declare const configActivityResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    actorEmail: z.ZodString;
+    actorType: z.ZodEnum<{
+        user: "user";
+        cli: "cli";
+        system: "system";
+    }>;
+    payload: z.ZodNullable<z.ZodUnknown>;
+    createdAt: z.ZodString;
+}, z.core.$strip>>;
+type ConfigCreateInput = z.infer<typeof configCreateSchema>;
+type ConfigUpdateInput = z.infer<typeof configUpdateSchema>;
+type ConfigSchemaUpdateInput = z.infer<typeof configSchemaUpdateSchema>;
+type ConfigDraftUpsertInput = z.infer<typeof configDraftUpsertSchema>;
+type ConfigPublishInput = z.infer<typeof configPublishSchema>;
+
+export { type ConfigCreateInput, type ConfigDraftUpsertInput, type ConfigPublishInput, type ConfigSchemaUpdateInput, type ConfigUpdateInput, type JsonSchemaInput, configActivityEntrySchema, configActivityResponseSchema, configCreateResponseSchema, configCreateSchema, configDeleteResponseSchema, configDraftDiscardResponseSchema, configDraftSaveResponseSchema, configDraftUpsertSchema, configEnvSchema, configKindSchema, configNameSchema, configPublishResponseSchema, configPublishSchema, configResponseSchema, configSchemaUpdateSchema, configUpdateResponseSchema, configUpdateSchema, jsonSchemaSchema };

package/dist/schemas/configs.js

@@ -0,0 +1,134 @@
+// 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.");
+export {
+  configActivityEntrySchema,
+  configActivityResponseSchema,
+  configCreateResponseSchema,
+  configCreateSchema,
+  configDeleteResponseSchema,
+  configDraftDiscardResponseSchema,
+  configDraftSaveResponseSchema,
+  configDraftUpsertSchema,
+  configEnvSchema,
+  configKindSchema,
+  configNameSchema,
+  configPublishResponseSchema,
+  configPublishSchema,
+  configResponseSchema,
+  configSchemaUpdateSchema,
+  configUpdateResponseSchema,
+  configUpdateSchema,
+  jsonSchemaSchema
+};

package/dist/schemas/constants.d.ts

@@ -0,0 +1,6 @@
+declare const CONFIG_ENVS: readonly ["dev", "staging", "prod"];
+type ConfigEnv = (typeof CONFIG_ENVS)[number];
+declare const CONFIG_KINDS: readonly ["config", "killswitch"];
+type ConfigKind = (typeof CONFIG_KINDS)[number];
+
+export { CONFIG_ENVS, CONFIG_KINDS, type ConfigEnv, type ConfigKind };

package/dist/schemas/constants.js

@@ -0,0 +1,7 @@
+// src/schemas/constants.ts
+var CONFIG_ENVS = ["dev", "staging", "prod"];
+var CONFIG_KINDS = ["config", "killswitch"];
+export {
+  CONFIG_ENVS,
+  CONFIG_KINDS
+};