@shipeasy/openapi 1.0.0 → 1.1.0

package/dist/schemas/experiments.d.ts

@@ -0,0 +1,245 @@
+import { z } from 'zod';
+
+declare const experimentInlineMetricSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    query: z.ZodString;
+}, z.core.$strip>;
+type ExperimentInlineMetric = z.infer<typeof experimentInlineMetricSchema>;
+declare const experimentNameSchema: z.ZodString;
+declare const experimentGroupSchema: z.ZodObject<{
+    name: z.ZodString;
+    weight: z.ZodNumber;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const paramSchemaSchema: z.ZodRecord<z.ZodString, z.ZodEnum<{
+    string: "string";
+    number: "number";
+    bool: "bool";
+}>>;
+declare const bucketBySchema: z.ZodEnum<{
+    user_id: "user_id";
+    session_id: "session_id";
+    device_id: "device_id";
+}>;
+declare const experimentCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    hypothesis: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    tag: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    owner_email: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    audience: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    bucket_by: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        user_id: "user_id";
+        session_id: "session_id";
+        device_id: "device_id";
+    }>>>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    universe: z.ZodString;
+    targeting_gate: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    allocation_pct: z.ZodDefault<z.ZodNumber>;
+    salt: z.ZodOptional<z.ZodString>;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        string: "string";
+        number: "number";
+        bool: "bool";
+    }>>>;
+    groups: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        weight: z.ZodNumber;
+        params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    significance_threshold: z.ZodDefault<z.ZodNumber>;
+    min_runtime_days: z.ZodDefault<z.ZodNumber>;
+    min_sample_size: z.ZodDefault<z.ZodNumber>;
+    sequential_testing: z.ZodDefault<z.ZodBoolean>;
+    goal_metric: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        query: z.ZodString;
+    }, z.core.$strip>>;
+    guardrail_metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        query: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const experimentUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hypothesis: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    owner_email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    audience: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    bucket_by: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        user_id: "user_id";
+        session_id: "session_id";
+        device_id: "device_id";
+    }>>>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    targeting_gate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    allocation_pct: z.ZodOptional<z.ZodNumber>;
+    salt: z.ZodOptional<z.ZodString>;
+    universe: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        string: "string";
+        number: "number";
+        bool: "bool";
+    }>>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        weight: z.ZodNumber;
+        params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    significance_threshold: z.ZodOptional<z.ZodNumber>;
+    min_runtime_days: z.ZodOptional<z.ZodNumber>;
+    min_sample_size: z.ZodOptional<z.ZodNumber>;
+    sequential_testing: z.ZodOptional<z.ZodBoolean>;
+    goal_metric: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        query: z.ZodString;
+    }, z.core.$strip>>;
+    guardrail_metrics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        query: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const experimentStatusUpdateSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        draft: "draft";
+        running: "running";
+        stopped: "stopped";
+        archived: "archived";
+    }>;
+}, z.core.$strip>;
+declare const experimentMetricsUpdateSchema: z.ZodObject<{
+    metrics: z.ZodArray<z.ZodObject<{
+        metric_id: z.ZodString;
+        role: z.ZodEnum<{
+            goal: "goal";
+            guardrail: "guardrail";
+            secondary: "secondary";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const experimentResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    hypothesis: z.ZodNullable<z.ZodString>;
+    tag: z.ZodNullable<z.ZodString>;
+    ownerEmail: z.ZodNullable<z.ZodString>;
+    audience: z.ZodNullable<z.ZodString>;
+    bucketBy: z.ZodNullable<z.ZodEnum<{
+        user_id: "user_id";
+        session_id: "session_id";
+        device_id: "device_id";
+    }>>;
+    folder: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        draft: "draft";
+        running: "running";
+        stopped: "stopped";
+        archived: "archived";
+    }>;
+    universe: z.ZodString;
+    targetingGate: z.ZodNullable<z.ZodString>;
+    allocationPct: z.ZodNumber;
+    salt: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodEnum<{
+        string: "string";
+        number: "number";
+        bool: "bool";
+    }>>;
+    groups: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        weight: z.ZodNumber;
+        params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    significanceThreshold: z.ZodNumber;
+    minRuntimeDays: z.ZodNumber;
+    minSampleSize: z.ZodNumber;
+    sequentialTesting: z.ZodBoolean;
+    startedAt: z.ZodNullable<z.ZodString>;
+    stoppedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+declare const experimentCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+declare const experimentUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+declare const experimentDeleteResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+declare const experimentStatusResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        running: "running";
+        stopped: "stopped";
+        archived: "archived";
+    }>;
+}, z.core.$strip>;
+declare const experimentMetricsResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    metrics: z.ZodArray<z.ZodObject<{
+        metric_id: z.ZodString;
+        role: z.ZodEnum<{
+            goal: "goal";
+            guardrail: "guardrail";
+            secondary: "secondary";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const experimentResultsResponseSchema: z.ZodObject<{
+    experiment: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            draft: "draft";
+            running: "running";
+            stopped: "stopped";
+            archived: "archived";
+        }>;
+    }, z.core.$strip>;
+    results: z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        group_name: z.ZodString;
+        ds: z.ZodString;
+        n: z.ZodNullable<z.ZodNumber>;
+        mean: z.ZodNullable<z.ZodNumber>;
+        delta_pct: z.ZodNullable<z.ZodNumber>;
+        p_value: z.ZodNullable<z.ZodNumber>;
+        srm_detected: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const experimentTimeseriesResponseSchema: z.ZodObject<{
+    experiment: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            draft: "draft";
+            running: "running";
+            stopped: "stopped";
+            archived: "archived";
+        }>;
+    }, z.core.$strip>;
+    series: z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        group_name: z.ZodString;
+        ds: z.ZodString;
+        n: z.ZodNullable<z.ZodNumber>;
+        mean: z.ZodNullable<z.ZodNumber>;
+        delta_pct: z.ZodNullable<z.ZodNumber>;
+        p_value: z.ZodNullable<z.ZodNumber>;
+        srm_detected: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const experimentReanalyzeResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    queued: z.ZodLiteral<true>;
+}, z.core.$strip>;
+type ExperimentCreateInput = z.infer<typeof experimentCreateSchema>;
+type ExperimentUpdateInput = z.infer<typeof experimentUpdateSchema>;
+
+export { type ExperimentCreateInput, type ExperimentInlineMetric, type ExperimentUpdateInput, bucketBySchema, experimentCreateResponseSchema, experimentCreateSchema, experimentDeleteResponseSchema, experimentGroupSchema, experimentInlineMetricSchema, experimentMetricsResponseSchema, experimentMetricsUpdateSchema, experimentNameSchema, experimentReanalyzeResponseSchema, experimentResponseSchema, experimentResultsResponseSchema, experimentStatusResponseSchema, experimentStatusUpdateSchema, experimentTimeseriesResponseSchema, experimentUpdateResponseSchema, experimentUpdateSchema, paramSchemaSchema };

package/dist/schemas/experiments.js

@@ -0,0 +1,216 @@
+// src/schemas/experiments.ts
+import { z as z3 } 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/metric-name.ts
+import { z as z2 } from "zod";
+var metricNameSchema = z2.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128);
+
+// src/schemas/experiments.ts
+var experimentInlineMetricSchema = z3.object({
+  name: metricNameSchema.optional(),
+  query: z3.string().min(1).max(4096).describe("Metric DSL string, e.g. `count_users(checkout_completed)`.")
+});
+var experimentNameSchema = z3.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128).describe(
+  "Stable experiment key. Single segment or `folder.name` (a-z, 0-9, `_`/`-`; max 128 chars). Used by SDKs as `Shipeasy.getExperiment(user, '<name>')`. Immutable after create."
+);
+var experimentGroupSchema = z3.object({
+  name: z3.string().min(1).max(64).describe("Group label (e.g. `control`, `treatment_a`). Max 64 chars."),
+  weight: z3.number().int().min(0).max(1e4).describe(
+    "Allocation weight in basis points (0\u201310000). The sum across all groups must equal exactly **10000** (100%)."
+  ),
+  params: z3.record(z3.string(), z3.unknown()).default({}).describe(
+    "Per-group parameter values delivered to the SDK when a caller is hashed into this group. Keys must match the experiment's `params` schema."
+  )
+}).describe("One variant in the experiment. Weights across all groups must sum to 10000.");
+var paramSchemaSchema = z3.record(z3.string(), z3.enum(["string", "bool", "number"])).describe(
+  "Map of param-name \u2192 scalar type. Defines the shape of `groups[].params`. Example: `{ headline: 'string', show_cta: 'bool' }`."
+);
+var bucketBySchema = z3.enum(["user_id", "session_id", "device_id"]).describe("Identifier used as the bucketing key. `user_id` is sticky across sessions.");
+var experimentCreateSchema = z3.object({
+  name: experimentNameSchema,
+  description: z3.string().max(2e3).nullable().default(null).describe("Free-form description. Max 2000 chars, markdown rendered in the dashboard."),
+  hypothesis: z3.string().max(4e3).nullable().default(null).describe("Hypothesis statement shown in the editor. Display-only."),
+  tag: z3.string().max(64).nullable().default(null).describe("Short tag chip rendered next to the name. Display-only."),
+  owner_email: z3.string().max(254).nullable().default(null).describe("Owner email. Display-only."),
+  audience: z3.string().max(256).nullable().default(null).describe("Audience label shown in the editor. Display-only."),
+  bucket_by: bucketBySchema.nullable().default(null),
+  folder: folderSchema,
+  universe: z3.string().min(1).describe(
+    "Name of an existing universe in the project. Returns `422` if the universe doesn't exist."
+  ),
+  targeting_gate: z3.string().nullable().default(null).describe(
+    "Optional gate name. Only callers that pass the gate are enrolled in the experiment."
+  ),
+  allocation_pct: z3.number().int().min(0).max(1e4).default(0).describe(
+    "Share of the (gated) audience allocated to the experiment, in basis points (0\u201310000 = 0%\u2013100%). `0` = unallocated. Immutable while the experiment is running."
+  ),
+  salt: z3.string().min(1).max(64).optional().describe("Hash salt for bucketing. Auto-generated if omitted. Immutable while running."),
+  params: paramSchemaSchema.default({}),
+  groups: z3.array(experimentGroupSchema).min(2).describe(
+    "Two or more variants. Weights must sum to exactly 10000 (100%). Immutable while running."
+  ),
+  significance_threshold: z3.number().min(1e-4).max(0.5).default(0.05).describe(
+    "p-value cutoff used by the analysis pass. Defaults to `0.05`. Values other than 0.05 require Pro plan or higher."
+  ),
+  min_runtime_days: z3.number().int().min(0).max(365).default(0).describe("Minimum days the experiment must run before results are considered conclusive."),
+  min_sample_size: z3.number().int().min(1).default(100).describe("Minimum exposures per group before results are considered conclusive."),
+  sequential_testing: z3.boolean().default(false).describe(
+    "Enable sequential testing (always-valid p-values). Requires Premium plan or higher."
+  ),
+  goal_metric: experimentInlineMetricSchema.optional().describe(
+    "Single goal metric defined inline as a DSL query. The underlying event is auto-created if missing."
+  ),
+  guardrail_metrics: z3.array(experimentInlineMetricSchema).max(10).default([]).describe(
+    "Up to 10 guardrail metrics defined inline. Each is upserted (event + metric) and attached with role=guardrail."
+  )
+}).refine(
+  (e) => e.groups.reduce((s, g) => s + g.weight, 0) === 1e4,
+  "groups weights must sum to exactly 10000"
+).describe(
+  "Body for `POST /api/admin/experiments`. `name`, `universe`, and `groups` (\u22652, weights sum to 10000) required."
+);
+var experimentUpdateSchema = z3.object({
+  name: experimentNameSchema.optional(),
+  description: z3.string().max(2e3).nullable().optional(),
+  hypothesis: z3.string().max(4e3).nullable().optional(),
+  tag: z3.string().max(64).nullable().optional(),
+  owner_email: z3.string().max(254).nullable().optional(),
+  audience: z3.string().max(256).nullable().optional(),
+  bucket_by: bucketBySchema.nullable().optional(),
+  folder: folderSchema,
+  targeting_gate: z3.string().nullable().optional(),
+  allocation_pct: z3.number().int().min(0).max(1e4).optional().describe("Basis-points allocation (0\u201310000). Immutable while the experiment is running."),
+  salt: z3.string().min(1).max(64).optional().describe("Hash salt. Immutable while running."),
+  universe: z3.string().optional().describe(
+    "New universe name. Immutable while running. Returns `422` if the universe doesn't exist."
+  ),
+  params: paramSchemaSchema.optional(),
+  groups: z3.array(experimentGroupSchema).min(2).optional().describe("Replacement groups. Weights must sum to 10000. Immutable while running."),
+  significance_threshold: z3.number().min(1e-4).max(0.5).optional(),
+  min_runtime_days: z3.number().int().min(0).max(365).optional(),
+  min_sample_size: z3.number().int().min(1).optional(),
+  sequential_testing: z3.boolean().optional(),
+  goal_metric: experimentInlineMetricSchema.optional().describe("Replaces the goal metric (event auto-upserted)."),
+  guardrail_metrics: z3.array(experimentInlineMetricSchema).max(10).optional().describe("Replaces the guardrail set wholesale (event auto-upserted per entry).")
+}).describe(
+  "Body for `PATCH /api/admin/experiments/{id}`. Partial \u2014 only supplied fields change. `allocation_pct`, `groups`, `salt`, `universe`, `params` are immutable while the experiment is running (stop first)."
+);
+var experimentStatusUpdateSchema = z3.object({
+  status: z3.enum(["draft", "running", "stopped", "archived"]).describe(
+    "Target status. Allowed transitions: `draft \u2192 running`, `running \u2192 stopped`, `stopped \u2192 archived`, `draft \u2192 archived`. Restarting an archived experiment is not allowed."
+  )
+}).describe("Body for `POST /api/admin/experiments/{id}/status`.");
+var experimentMetricsUpdateSchema = z3.object({
+  metrics: z3.array(
+    z3.object({
+      metric_id: z3.string().describe("Existing metric id in the project."),
+      role: z3.enum(["goal", "guardrail", "secondary"]).describe(
+        "Metric role. `goal` drives the decision, `guardrail` blocks ship if degraded, `secondary` is informational."
+      )
+    })
+  ).describe("Replacement metrics list \u2014 replaces the current attachments wholesale.")
+}).describe(
+  "Body for `POST /api/admin/experiments/{id}/metrics`. Replaces the experiment's metric attachments wholesale. Returns `422` if any `metric_id` is unknown."
+);
+var experimentResponseSchema = z3.object({
+  id: z3.string().describe("Stable opaque experiment id (`exp_\u2026`)."),
+  name: experimentNameSchema,
+  description: z3.string().nullable(),
+  hypothesis: z3.string().nullable(),
+  tag: z3.string().nullable(),
+  ownerEmail: z3.string().nullable(),
+  audience: z3.string().nullable(),
+  bucketBy: bucketBySchema.nullable(),
+  folder: z3.string().nullable(),
+  status: z3.enum(["draft", "running", "stopped", "archived"]),
+  universe: z3.string().describe("Universe name this experiment draws from."),
+  targetingGate: z3.string().nullable(),
+  allocationPct: z3.number().int().describe("Allocation in basis points (0\u201310000)."),
+  salt: z3.string(),
+  params: z3.record(z3.string(), z3.enum(["string", "bool", "number"])),
+  groups: z3.array(experimentGroupSchema),
+  significanceThreshold: z3.number(),
+  minRuntimeDays: z3.number().int(),
+  minSampleSize: z3.number().int(),
+  sequentialTesting: z3.boolean(),
+  startedAt: z3.string().nullable().describe("ISO-8601 timestamp the experiment last transitioned to `running`, or `null`."),
+  stoppedAt: z3.string().nullable().optional(),
+  updatedAt: z3.string()
+});
+var experimentCreateResponseSchema = z3.object({
+  id: z3.string().describe("Newly assigned experiment id."),
+  name: experimentNameSchema
+});
+var experimentUpdateResponseSchema = z3.object({
+  id: z3.string().describe("Experiment id that was updated.")
+});
+var experimentDeleteResponseSchema = z3.object({ ok: z3.literal(true) });
+var experimentStatusResponseSchema = z3.object({
+  id: z3.string(),
+  status: z3.enum(["draft", "running", "stopped", "archived"])
+});
+var experimentMetricsResponseSchema = z3.object({
+  id: z3.string(),
+  metrics: z3.array(
+    z3.object({
+      metric_id: z3.string(),
+      role: z3.enum(["goal", "guardrail", "secondary"])
+    })
+  )
+});
+var experimentResultRowSchema = z3.object({
+  metric: z3.string(),
+  group_name: z3.string(),
+  ds: z3.string().describe("Date slice (`YYYY-MM-DD`)."),
+  n: z3.number().nullable(),
+  mean: z3.number().nullable(),
+  delta_pct: z3.number().nullable(),
+  p_value: z3.number().nullable(),
+  srm_detected: z3.number().nullable().describe("`1` if sample-ratio mismatch detected, else `0`.")
+});
+var experimentResultsResponseSchema = z3.object({
+  experiment: z3.object({
+    id: z3.string(),
+    name: experimentNameSchema,
+    status: z3.enum(["draft", "running", "stopped", "archived"])
+  }),
+  results: z3.array(experimentResultRowSchema)
+});
+var experimentTimeseriesResponseSchema = z3.object({
+  experiment: z3.object({
+    id: z3.string(),
+    name: experimentNameSchema,
+    status: z3.enum(["draft", "running", "stopped", "archived"])
+  }),
+  series: z3.array(experimentResultRowSchema)
+});
+var experimentReanalyzeResponseSchema = z3.object({
+  id: z3.string(),
+  queued: z3.literal(true)
+});
+export {
+  bucketBySchema,
+  experimentCreateResponseSchema,
+  experimentCreateSchema,
+  experimentDeleteResponseSchema,
+  experimentGroupSchema,
+  experimentInlineMetricSchema,
+  experimentMetricsResponseSchema,
+  experimentMetricsUpdateSchema,
+  experimentNameSchema,
+  experimentReanalyzeResponseSchema,
+  experimentResponseSchema,
+  experimentResultsResponseSchema,
+  experimentStatusResponseSchema,
+  experimentStatusUpdateSchema,
+  experimentTimeseriesResponseSchema,
+  experimentUpdateResponseSchema,
+  experimentUpdateSchema,
+  paramSchemaSchema
+};

package/dist/schemas/folder.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+/** Folder name validation shared across every entity that supports folders.
+ *  Flat string — no `/` allowed because `/` is the folder/name separator in
+ *  SDK lookup keys (see KV blob format 3). Empty string is coerced to null
+ *  at the boundary so the DB stores a single canonical "no folder" value. */
+declare const folderSchema: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+type FolderInput = z.infer<typeof folderSchema>;
+
+export { type FolderInput, folderSchema };

package/dist/schemas/folder.js

@@ -0,0 +1,8 @@
+// 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."
+);
+export {
+  folderSchema
+};