@mutagent/sdk 0.3.41 → 0.3.42

package/src/models/operations/post-api-sandbox-by-id-checkpoint.ts

@@ -0,0 +1,151 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+/**
+ * Capture a running Helix session's own transcript into a snapshot
+ */
+export type PostApiSandboxByIdCheckpointRequestBody = {
+  /**
+   * The Helix session to capture — from the `start` that created it. The harness writes its session file LAZILY, so a session that has not completed a turn has nothing to capture and answers 409.
+   */
+  sessionId: string;
+};
+
+export type PostApiSandboxByIdCheckpointRequest = {
+  id: string;
+  /**
+   * Capture a running Helix session's own transcript into a snapshot
+   */
+  body: PostApiSandboxByIdCheckpointRequestBody;
+};
+
+/**
+ * A stored checkpoint of the agent’s own conversation state
+ */
+export type PostApiSandboxByIdCheckpointResponse = {
+  /**
+   * Names the snapshot in a later restore.
+   */
+  snapshotId: string;
+  /**
+   * Size of the captured file in RAW bytes, not base64.
+   */
+  bytes: number;
+  /**
+   * sha256 of the raw bytes, hex. A restore re-reads this from the receiving box and refuses to switch the session if it differs.
+   */
+  sha256: string;
+  /**
+   * The harness's OWN session id, from inside the file. Distinct from the control-plane sessionId, and the one that survives a restore.
+   */
+  harnessSessionId: string;
+  /**
+   * Messages the harness reported at capture time. Never zero — a zero capture is refused.
+   */
+  messageCount: number;
+  /**
+   * Where the file lived on the origin box. Diagnostic only — a restore derives its path from the RECEIVING box, since cwd is a per-session choice.
+   */
+  sourcePath: string;
+  /**
+   * Where the settings-and-queue manifest was written in the object store, or null when this deployment has none. The manifest also holds the workspace and extension-state archive references.
+   */
+  manifestKey: string | null;
+  /**
+   * Size of the workspace archive that travelled with this checkpoint. Null when none did.
+   */
+  workspaceBytes: number | null;
+  /**
+   * How many files that archive holds. Null when no workspace travelled.
+   */
+  workspaceFiles: number | null;
+  /**
+   * One line per leg that did NOT travel, each naming the leg and the reason. Empty means everything was captured. Read this before treating a 200 as a full-state checkpoint: a capture that stored the conversation and carried no workspace is a legitimate outcome and must not look like one that carried it.
+   */
+  notCaptured: Array<string>;
+};
+
+/** @internal */
+export type PostApiSandboxByIdCheckpointRequestBody$Outbound = {
+  sessionId: string;
+};
+
+/** @internal */
+export const PostApiSandboxByIdCheckpointRequestBody$outboundSchema:
+  z.ZodMiniType<
+    PostApiSandboxByIdCheckpointRequestBody$Outbound,
+    PostApiSandboxByIdCheckpointRequestBody
+  > = z.object({
+    sessionId: z.string(),
+  });
+
+export function postApiSandboxByIdCheckpointRequestBodyToJSON(
+  postApiSandboxByIdCheckpointRequestBody:
+    PostApiSandboxByIdCheckpointRequestBody,
+): string {
+  return JSON.stringify(
+    PostApiSandboxByIdCheckpointRequestBody$outboundSchema.parse(
+      postApiSandboxByIdCheckpointRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type PostApiSandboxByIdCheckpointRequest$Outbound = {
+  id: string;
+  body: PostApiSandboxByIdCheckpointRequestBody$Outbound;
+};
+
+/** @internal */
+export const PostApiSandboxByIdCheckpointRequest$outboundSchema: z.ZodMiniType<
+  PostApiSandboxByIdCheckpointRequest$Outbound,
+  PostApiSandboxByIdCheckpointRequest
+> = z.object({
+  id: z.string(),
+  body: z.lazy(() => PostApiSandboxByIdCheckpointRequestBody$outboundSchema),
+});
+
+export function postApiSandboxByIdCheckpointRequestToJSON(
+  postApiSandboxByIdCheckpointRequest: PostApiSandboxByIdCheckpointRequest,
+): string {
+  return JSON.stringify(
+    PostApiSandboxByIdCheckpointRequest$outboundSchema.parse(
+      postApiSandboxByIdCheckpointRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const PostApiSandboxByIdCheckpointResponse$inboundSchema: z.ZodMiniType<
+  PostApiSandboxByIdCheckpointResponse,
+  unknown
+> = z.object({
+  snapshotId: types.string(),
+  bytes: types.number(),
+  sha256: types.string(),
+  harnessSessionId: types.string(),
+  messageCount: types.number(),
+  sourcePath: types.string(),
+  manifestKey: types.nullable(types.string()),
+  workspaceBytes: types.nullable(types.number()),
+  workspaceFiles: types.nullable(types.number()),
+  notCaptured: z.array(types.string()),
+});
+
+export function postApiSandboxByIdCheckpointResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostApiSandboxByIdCheckpointResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PostApiSandboxByIdCheckpointResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostApiSandboxByIdCheckpointResponse' from JSON`,
+  );
+}

package/src/models/operations/post-api-sandbox-by-id-restore.ts

@@ -0,0 +1,263 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+
+export type PostApiSandboxByIdRestoreRequest = {
+  id: string;
+  /**
+   * Rebuild this sandbox from a checkpoint: a fresh box under the SAME id at generation+1, the workspace and extension state extracted before Helix starts, the conversation restored and switched to, then the runtime settings and pending queue replayed.
+   */
+  body: models.SnapshotIdDefinitionPartial;
+};
+
+export type Workspace = {
+  files: number;
+  bytes: number;
+};
+
+/**
+ * `clean` — probed, the box has every referenced file. `drifted` — probed, `missing` lists what it lacks. `unchecked` — no probe ran (`reason` says why); NOT a clean bill of health.
+ */
+export enum Status {
+  Clean = "clean",
+  Drifted = "drifted",
+  Unchecked = "unchecked",
+}
+/**
+ * `clean` — probed, the box has every referenced file. `drifted` — probed, `missing` lists what it lacks. `unchecked` — no probe ran (`reason` says why); NOT a clean bill of health.
+ */
+export type StatusOpen = OpenEnum<typeof Status>;
+
+/**
+ * Whether the restored context refers to files this box does not have
+ */
+export type WorkspaceDrift = {
+  /**
+   * `clean` — probed, the box has every referenced file. `drifted` — probed, `missing` lists what it lacks. `unchecked` — no probe ran (`reason` says why); NOT a clean bill of health.
+   */
+  status: StatusOpen;
+  /**
+   * How many files the transcript was found to claim. A FLOOR, not a count of the workspace: detection reads write-shaped tool calls only, so files created by shell are invisible to it.
+   */
+  referenced: number;
+  /**
+   * Referenced paths the box does not have. VERIFIED by the box, not inferred — the candidate list is heuristic, this absence is not.
+   */
+  missing: Array<string>;
+  /**
+   * The detector’s own read was incomplete — it hit its path cap or met lines it could not parse. An empty `missing` under `partial: true` proves less than it appears to.
+   */
+  partial: boolean;
+  /**
+   * Why `status` is `unchecked`. Absent otherwise.
+   */
+  reason?: string | undefined;
+};
+
+export type SkippedSnapshot = {
+  id: string;
+  reason: string;
+};
+
+/**
+ * The sandbox has been rebuilt and the agent is continuing the checkpoint’s conversation
+ */
+export type PostApiSandboxByIdRestoreResponse = {
+  /**
+   * True only. The digest matched and the harness confirmed the switch; anything else is an error status, never a `false` here.
+   */
+  restored: boolean;
+  /**
+   * UNCHANGED across the restore. That is the design: the logical sandbox keeps its id so a client cursor stays valid, and `generation` is what says the instance underneath was replaced.
+   */
+  sandboxId: string;
+  /**
+   * The previous generation plus one.
+   */
+  generation: number;
+  snapshotId: string;
+  /**
+   * The NEW control-plane Helix session in the rebuilt box. Use it for `POST /:id/input`.
+   */
+  sessionId: string;
+  /**
+   * The harness's OWN session id, carried through from the snapshot. Unlike `sessionId` it survives the restore, so it is what identifies one conversation across the seam.
+   */
+  harnessSessionId: string;
+  /**
+   * The working directory the restored session runs in, from the checkpoint. Null when the checkpoint recorded none.
+   */
+  cwd: string | null;
+  bytes: number;
+  /**
+   * What the box reported. Equal to the stored digest, or this call failed.
+   */
+  sha256: string;
+  /**
+   * The wire seq the `restored` marker took on the stream. It CONTINUES the killed instance's numbering, which is what lets a client keep using its old `?since=` cursor. -1 when this deployment has no event relay and no marker could be written.
+   */
+  seq: number;
+  /**
+   * Which runtime modes were actually replayed onto the restored session. A mode the checkpoint did not record is not replayed — imposing a default nobody chose is worse than leaving one unset.
+   */
+  settingsReplayed: Array<string>;
+  /**
+   * How many pending steer/follow-up instructions were re-enqueued.
+   */
+  queueReplayed: number;
+  /**
+   * What the workspace archive put back, or null when none travelled.
+   */
+  workspace: Workspace | null;
+  /**
+   * Whether the restored context refers to files this box does not have
+   */
+  workspaceDrift: WorkspaceDrift;
+  /**
+   * One line per thing that did NOT come back, each naming the leg and why. Read this before believing the rest: restoring the conversation alone is a legitimate outcome (a deployment with no object store, or a checkpoint whose manifest never landed) and must not be indistinguishable from a full-state restore.
+   */
+  notRestored: Array<string>;
+  /**
+   * True when the transcript restored is the incremental prefix beyond the checkpoint (`partial: true` was asked AND the prefix extended the row). The `session {status:"restored"}` frame carries the same flag. False when the checkpoint row was restored — including a `partial: true` request that fell back, which `notRestored` explains.
+   */
+  partial: boolean;
+  /**
+   * Transcript bytes restored BEYOND the checkpoint row. 0 unless `partial`.
+   */
+  partialBytes: number;
+  /**
+   * Newer checkpoints a DEFAULTED restore passed over to reach one with a manifest, each with why. A consistency point writes its conversation row first and its manifest last, so a box that dies in between leaves a newest row that cannot be restored in full; the default walks back to the newest one that can and names what it skipped here. Empty when the newest row was used or when `snapshotId` was given (a named snapshot is restored as-is, with the session file’s own header cwd when it has no manifest).
+   */
+  skippedSnapshots: Array<SkippedSnapshot>;
+};
+
+/** @internal */
+export type PostApiSandboxByIdRestoreRequest$Outbound = {
+  id: string;
+  body: models.SnapshotIdDefinitionPartial$Outbound;
+};
+
+/** @internal */
+export const PostApiSandboxByIdRestoreRequest$outboundSchema: z.ZodMiniType<
+  PostApiSandboxByIdRestoreRequest$Outbound,
+  PostApiSandboxByIdRestoreRequest
+> = z.object({
+  id: z.string(),
+  body: models.SnapshotIdDefinitionPartial$outboundSchema,
+});
+
+export function postApiSandboxByIdRestoreRequestToJSON(
+  postApiSandboxByIdRestoreRequest: PostApiSandboxByIdRestoreRequest,
+): string {
+  return JSON.stringify(
+    PostApiSandboxByIdRestoreRequest$outboundSchema.parse(
+      postApiSandboxByIdRestoreRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const Workspace$inboundSchema: z.ZodMiniType<Workspace, unknown> = z
+  .object({
+    files: types.number(),
+    bytes: types.number(),
+  });
+
+export function workspaceFromJSON(
+  jsonString: string,
+): SafeParseResult<Workspace, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Workspace$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Workspace' from JSON`,
+  );
+}
+
+/** @internal */
+export const Status$inboundSchema: z.ZodMiniType<StatusOpen, unknown> =
+  openEnums.inboundSchema(Status);
+
+/** @internal */
+export const WorkspaceDrift$inboundSchema: z.ZodMiniType<
+  WorkspaceDrift,
+  unknown
+> = z.object({
+  status: z._default(Status$inboundSchema, Status.Clean),
+  referenced: types.number(),
+  missing: z.array(types.string()),
+  partial: types.boolean(),
+  reason: types.optional(types.string()),
+});
+
+export function workspaceDriftFromJSON(
+  jsonString: string,
+): SafeParseResult<WorkspaceDrift, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorkspaceDrift$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorkspaceDrift' from JSON`,
+  );
+}
+
+/** @internal */
+export const SkippedSnapshot$inboundSchema: z.ZodMiniType<
+  SkippedSnapshot,
+  unknown
+> = z.object({
+  id: types.string(),
+  reason: types.string(),
+});
+
+export function skippedSnapshotFromJSON(
+  jsonString: string,
+): SafeParseResult<SkippedSnapshot, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SkippedSnapshot$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SkippedSnapshot' from JSON`,
+  );
+}
+
+/** @internal */
+export const PostApiSandboxByIdRestoreResponse$inboundSchema: z.ZodMiniType<
+  PostApiSandboxByIdRestoreResponse,
+  unknown
+> = z.object({
+  restored: types.boolean(),
+  sandboxId: types.string(),
+  generation: types.number(),
+  snapshotId: types.string(),
+  sessionId: types.string(),
+  harnessSessionId: types.string(),
+  cwd: types.nullable(types.string()),
+  bytes: types.number(),
+  sha256: types.string(),
+  seq: types.number(),
+  settingsReplayed: z.array(types.string()),
+  queueReplayed: types.number(),
+  workspace: types.nullable(z.lazy(() => Workspace$inboundSchema)),
+  workspaceDrift: z.lazy(() => WorkspaceDrift$inboundSchema),
+  notRestored: z.array(types.string()),
+  partial: types.boolean(),
+  partialBytes: types.number(),
+  skippedSnapshots: z.array(z.lazy(() => SkippedSnapshot$inboundSchema)),
+});
+
+export function postApiSandboxByIdRestoreResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PostApiSandboxByIdRestoreResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PostApiSandboxByIdRestoreResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PostApiSandboxByIdRestoreResponse' from JSON`,
+  );
+}

package/src/models/operations/post-api-sandbox-by-id-session.ts

@@ -14,7 +14,7 @@ export type PostApiSandboxByIdSessionRequest = {
   /**
    * Start a Helix session inside a running sandbox
    */
-  body: models.ModeArgsEnv;
+  body: models.ModeArmArgs;
 };
 
 /**
@@ -32,13 +32,17 @@ export type PostApiSandboxByIdSessionResponse = {
   /**
    * The mode the session was actually started in.
    */
-  mode: models.Schemadefaul5Open;
+  mode: models.Schemadefaul6Open;
+  /**
+   * The launcher arm the session was actually started on.
+   */
+  arm: models.Schemadefaul7Open;
 };
 
 /** @internal */
 export type PostApiSandboxByIdSessionRequest$Outbound = {
   id: string;
-  body: models.ModeArgsEnv$Outbound;
+  body: models.ModeArmArgs$Outbound;
 };
 
 /** @internal */
@@ -47,7 +51,7 @@ export const PostApiSandboxByIdSessionRequest$outboundSchema: z.ZodMiniType<
   PostApiSandboxByIdSessionRequest
 > = z.object({
   id: z.string(),
-  body: models.ModeArgsEnv$outboundSchema,
+  body: models.ModeArmArgs$outboundSchema,
 });
 
 export function postApiSandboxByIdSessionRequestToJSON(
@@ -68,8 +72,12 @@ export const PostApiSandboxByIdSessionResponse$inboundSchema: z.ZodMiniType<
   sessionId: types.string(),
   status: types.string(),
   mode: z._default(
-    models.Schemadefaul5$inboundSchema,
-    models.Schemadefaul5.Oneshot,
+    models.Schemadefaul6$inboundSchema,
+    models.Schemadefaul6.Oneshot,
+  ),
+  arm: z._default(
+    models.Schemadefaul7$inboundSchema,
+    models.Schemadefaul7.Classic,
   ),
 });
 

package/src/models/operations/post-api-sandbox.ts

@@ -29,7 +29,7 @@ export type PostApiSandboxResponse = {
    * CPU architecture the image was built for. Validated against the provider at preflight.
    */
   arch: models.SchemadefaulOpen;
-  status: models.Schemadefaul4Open;
+  status: models.Schemadefaul5Open;
   definitionName: string;
   environmentName?: string | undefined;
   /**
@@ -51,8 +51,8 @@ export const PostApiSandboxResponse$inboundSchema: z.ZodMiniType<
     models.Schemadefaul.X8664,
   ),
   status: z._default(
-    models.Schemadefaul4$inboundSchema,
-    models.Schemadefaul4.Pending,
+    models.Schemadefaul5$inboundSchema,
+    models.Schemadefaul5.Pending,
   ),
   definitionName: types.string(),
   environmentName: types.optional(types.string()),

package/src/models/operations/update-organization-member.ts

@@ -9,7 +9,7 @@ export type UpdateOrganizationMemberRequestBody = {
   /**
    * The new role for the member
    */
-  role?: models.Schemadefaul6 | undefined;
+  role?: models.Schemadefaul9 | undefined;
 };
 
 export type UpdateOrganizationMemberRequest = {
@@ -29,8 +29,8 @@ export const UpdateOrganizationMemberRequestBody$outboundSchema: z.ZodMiniType<
   UpdateOrganizationMemberRequestBody
 > = z.object({
   role: z._default(
-    models.Schemadefaul6$outboundSchema,
-    models.Schemadefaul6.Owner,
+    models.Schemadefaul9$outboundSchema,
+    models.Schemadefaul9.Owner,
   ),
 });
 

package/src/models/operations/update-workspace-member.ts

@@ -9,7 +9,7 @@ export type UpdateWorkspaceMemberRequestBody = {
   /**
    * The new role for the member
    */
-  role?: models.Schemadefaul8 | undefined;
+  role?: models.Schemadefaul11 | undefined;
 };
 
 export type UpdateWorkspaceMemberRequest = {
@@ -29,8 +29,8 @@ export const UpdateWorkspaceMemberRequestBody$outboundSchema: z.ZodMiniType<
   UpdateWorkspaceMemberRequestBody
 > = z.object({
   role: z._default(
-    models.Schemadefaul8$outboundSchema,
-    models.Schemadefaul8.Admin,
+    models.Schemadefaul11$outboundSchema,
+    models.Schemadefaul11.Admin,
   ),
 });
 

package/src/models/preset-timeout-ms-keep2.ts

@@ -33,6 +33,14 @@ export type PresetTimeoutMsKeep2 = {
    * Run the agent on the ASPS-Prime scaffold instead of the default ASPS one — leaner, code-first, no orchestrator persona. Forwarded to the binary as `--prime`.
    */
   prime?: boolean | undefined;
+  /**
+   * Harness argv, forwarded verbatim between the definition flags and `-p <task>`. Not interpreted here: the flag vocabulary belongs to the binary. Max 64 entries, 4 KiB each, no NUL.
+   */
+  args?: Array<string> | undefined;
+  /**
+   * Working directory for the turn inside the sandbox. Omitted takes the box default.
+   */
+  cwd?: string | undefined;
 };
 
 /** @internal */
@@ -44,6 +52,8 @@ export type PresetTimeoutMsKeep2$Outbound = {
   prompt: string;
   task: string;
   prime?: boolean | undefined;
+  args?: Array<string> | undefined;
+  cwd?: string | undefined;
 };
 
 /** @internal */
@@ -58,6 +68,8 @@ export const PresetTimeoutMsKeep2$outboundSchema: z.ZodMiniType<
   prompt: z.string(),
   task: z.string(),
   prime: z.optional(z.boolean()),
+  args: z.optional(z.array(z.string())),
+  cwd: z.optional(z.string()),
 });
 
 export function presetTimeoutMsKeep2ToJSON(

package/src/models/{schemadefaul8.ts → schemadefaul11.ts}

@@ -4,12 +4,13 @@
 
 import * as z from "zod/v4-mini";
 
-export enum Schemadefaul8 {
+export enum Schemadefaul11 {
   Admin = "admin",
   Editor = "editor",
   Viewer = "viewer",
 }
 
 /** @internal */
-export const Schemadefaul8$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul8> =
-  z.enum(Schemadefaul8);
+export const Schemadefaul11$outboundSchema: z.ZodMiniEnum<
+  typeof Schemadefaul11
+> = z.enum(Schemadefaul11);

package/src/models/schemadefaul5.ts

@@ -7,8 +7,13 @@ import * as openEnums from "../types/enums.js";
 import { OpenEnum } from "../types/enums.js";
 
 export enum Schemadefaul5 {
-  Oneshot = "oneshot",
-  Rpc = "rpc",
+  Pending = "pending",
+  Starting = "starting",
+  Running = "running",
+  Paused = "paused",
+  Stopping = "stopping",
+  Stopped = "stopped",
+  Failed = "failed",
 }
 export type Schemadefaul5Open = OpenEnum<typeof Schemadefaul5>;
 
@@ -17,8 +22,3 @@ export const Schemadefaul5$inboundSchema: z.ZodMiniType<
   Schemadefaul5Open,
   unknown
 > = openEnums.inboundSchema(Schemadefaul5);
-/** @internal */
-export const Schemadefaul5$outboundSchema: z.ZodMiniType<
-  string,
-  Schemadefaul5Open
-> = openEnums.outboundSchema(Schemadefaul5);

package/src/models/schemadefaul6.ts

@@ -3,14 +3,22 @@
  */
 
 import * as z from "zod/v4-mini";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 
 export enum Schemadefaul6 {
-  Owner = "owner",
-  Admin = "admin",
-  Editor = "editor",
-  Viewer = "viewer",
+  Oneshot = "oneshot",
+  Rpc = "rpc",
 }
+export type Schemadefaul6Open = OpenEnum<typeof Schemadefaul6>;
 
 /** @internal */
-export const Schemadefaul6$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul6> =
-  z.enum(Schemadefaul6);
+export const Schemadefaul6$inboundSchema: z.ZodMiniType<
+  Schemadefaul6Open,
+  unknown
+> = openEnums.inboundSchema(Schemadefaul6);
+/** @internal */
+export const Schemadefaul6$outboundSchema: z.ZodMiniType<
+  string,
+  Schemadefaul6Open
+> = openEnums.outboundSchema(Schemadefaul6);

package/src/models/schemadefaul7.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
+
+export enum Schemadefaul7 {
+  Classic = "classic",
+  Prime = "prime",
+  Agent = "agent",
+}
+export type Schemadefaul7Open = OpenEnum<typeof Schemadefaul7>;
+
+/** @internal */
+export const Schemadefaul7$inboundSchema: z.ZodMiniType<
+  Schemadefaul7Open,
+  unknown
+> = openEnums.inboundSchema(Schemadefaul7);
+/** @internal */
+export const Schemadefaul7$outboundSchema: z.ZodMiniType<
+  string,
+  Schemadefaul7Open
+> = openEnums.outboundSchema(Schemadefaul7);

package/src/models/schemadefaul9.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export enum Schemadefaul9 {
+  Owner = "owner",
+  Admin = "admin",
+  Editor = "editor",
+  Viewer = "viewer",
+}
+
+/** @internal */
+export const Schemadefaul9$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul9> =
+  z.enum(Schemadefaul9);