@statelyai/sdk 0.34.2 → 0.36.0

package/dist/studio-BZP6DaIO.mjs

@@ -1,638 +0,0 @@
-import { c as object, d as union, f as unknown, l as record, n as array, o as literal, r as boolean, s as number, t as _enum, u as string } from "./openapi-BTDjYWXd.mjs";
-import { createAuthorizationHeader, getCredentialToken } from "./auth.mjs";
-
-//#region ../api-contract/dist/errors.mjs
-/**
-* Error shape returned by every `/api/v1` machine operation (and by the shared
-* auth guard). Each operation registers its own error schema component in the
-* OpenAPI document, so this is a factory rather than a single shared instance.
-*/
-function createApiErrorResponseSchema() {
-	return object({
-		error: string(),
-		issues: array(unknown()).optional()
-	});
-}
-const apiErrorResponseSchema = createApiErrorResponseSchema();
-/**
-* Canonical error codes for the `/api/v1` resource operations. Machine
-* operations keep the flat `{ error: string }` shape above unchanged; the
-* nested envelope below applies to resource operations only.
-*/
-const resourceErrorCodeSchema = _enum([
-	"bad_request",
-	"unauthenticated",
-	"forbidden",
-	"not_found",
-	"conflict",
-	"payload_too_large",
-	"rate_limited",
-	"capability_disabled",
-	"upstream_error",
-	"internal_error"
-]);
-/** Factory, matching `createApiErrorResponseSchema`, for per-route OpenAPI components. */
-function createResourceApiErrorResponseSchema() {
-	return object({ error: object({
-		code: resourceErrorCodeSchema,
-		message: string(),
-		issues: array(unknown()).optional(),
-		retryable: boolean().optional()
-	}) });
-}
-const resourceApiErrorResponseSchema = createResourceApiErrorResponseSchema();
-
-//#endregion
-//#region ../api-contract/dist/xgraph.mjs
-const looseRecordSchema = record(string(), unknown());
-const pointSchema = object({
-	x: number(),
-	y: number()
-});
-const nodeDataSchema = looseRecordSchema.refine((data) => !("parentId" in data), "XGraph node data must not contain parentId; use node.parentId.");
-const xgraphNodeSchema = object({
-	id: string(),
-	type: string().optional(),
-	parentId: string().nullable().optional(),
-	sourceId: string().optional(),
-	targetId: string().optional(),
-	label: string().nullable().optional(),
-	data: nodeDataSchema.optional(),
-	x: number().optional(),
-	y: number().optional(),
-	width: number().optional(),
-	height: number().optional(),
-	position: pointSchema.optional(),
-	dx: number().optional(),
-	dy: number().optional()
-}).passthrough();
-const xgraphEdgeSchema = object({
-	id: string(),
-	type: string().optional(),
-	sourceId: string(),
-	targetId: string(),
-	label: string().nullable().optional(),
-	data: unknown(),
-	x: number().optional(),
-	y: number().optional(),
-	width: number().optional(),
-	height: number().optional(),
-	position: pointSchema.optional(),
-	dx: number().optional(),
-	dy: number().optional()
-}).passthrough();
-/** XGraph wire shape accepted and emitted at API boundaries. */
-const xgraphSchema = object({
-	xgraphSchemaVersion: literal("1.0.0").optional(),
-	id: string(),
-	type: string().optional(),
-	parentId: string().nullable().optional(),
-	initialNodeId: string().nullable().optional(),
-	nodes: array(xgraphNodeSchema),
-	edges: array(xgraphEdgeSchema),
-	data: unknown().optional(),
-	layout: unknown().nullable().optional(),
-	annotations: array(unknown()).optional(),
-	direction: _enum([
-		"up",
-		"down",
-		"left",
-		"right"
-	]).optional(),
-	style: looseRecordSchema.optional()
-}).passthrough();
-
-//#endregion
-//#region ../api-contract/dist/resources.mjs
-/**
-* Canonical schemas for persistent `/api/v1` resources plus the owned,
-* deterministic code-extraction operation.
-*
-* These models are canonical, not upstream-shaped: providers (e.g. the Stately
-* Registry adapter) are responsible for translating upstream envelopes,
-* identifier quirks and casing into these shapes. No `{ data }` envelope
-* appears anywhere; all timestamps are ISO strings.
-*/
-/**
-* XState major versions the editor targets (see
-* `packages/editor/src/formats/xstate.ts`).
-*/
-const xstateVersionSchema = union([literal(5), literal(6)]);
-const projectVisibilitySchema = _enum([
-	"public",
-	"unlisted",
-	"private"
-]);
-const verifyResultSchema = object({
-	valid: literal(true),
-	tokenScope: _enum(["user", "project"])
-});
-/**
-* Entitlements for the authenticated caller.
-*
-* Internal contract: this is not published as an `/api/v1` operation. Editor
-* feature gating resolves it server-side through the resource provider and
-* hands the mapped result to the client (see
-* `packages/editor/src/entitlements`).
-*
-* `entitlements` is an open set of provider-defined strings; unknown values are
-* ignored rather than rejected.
-*/
-const entitlementsResultSchema = object({
-	subscription: object({
-		tier: string(),
-		status: string()
-	}).nullable(),
-	entitlements: array(string())
-});
-/**
-* Which editor format a machine's stored definition is in: `digraph` is the
-* original (legacy) editor's format, `xgraph` the current one.
-*/
-const machineDefinitionFormatSchema = _enum(["digraph", "xgraph"]);
-/**
-* `name` and `updatedAt` are optional: some upstream project envelopes only
-* return machine ids. Providers that can supply them cheaply should.
-*/
-const projectMachineSummarySchema = object({
-	machineId: string(),
-	name: string().optional(),
-	updatedAt: string().optional(),
-	format: machineDefinitionFormatSchema.optional()
-});
-/**
-* A project list row. It carries the project's machine roster, not just its
-* metadata, so a client can mount a whole workspace from one `projects.list`
-* response and fetch definitions lazily.
-*/
-const projectSummarySchema = object({
-	projectId: string(),
-	projectVersionId: string(),
-	name: string(),
-	description: string().nullable(),
-	visibility: projectVisibilitySchema,
-	createdAt: string(),
-	updatedAt: string(),
-	rootMachineId: string().nullable().optional(),
-	machines: array(projectMachineSummarySchema).optional(),
-	permissions: object({ canEdit: boolean() }).optional(),
-	allowedVisibility: array(projectVisibilitySchema).optional()
-});
-const projectSchema = projectSummarySchema.extend({
-	rootMachineId: string().nullable(),
-	machines: array(projectMachineSummarySchema),
-	permissions: object({ canEdit: boolean() })
-});
-const machineSchema = object({
-	machineId: string(),
-	name: string(),
-	projectId: string().optional(),
-	projectVersionId: string(),
-	definition: unknown(),
-	graph: xgraphSchema.optional(),
-	createdAt: string().optional(),
-	updatedAt: string().optional(),
-	format: machineDefinitionFormatSchema.optional()
-});
-const machineVersionSchema = object({
-	machineVersionId: string(),
-	machineId: string(),
-	versionNumber: number(),
-	name: string(),
-	definition: unknown(),
-	createdAt: string(),
-	updatedAt: string(),
-	format: machineDefinitionFormatSchema.optional()
-});
-/** Version-history row without the definition payload. */
-const machineVersionSummarySchema = object({
-	machineVersionId: string(),
-	machineId: string(),
-	versionNumber: number(),
-	name: string().nullable(),
-	status: string(),
-	parentVersionId: string().nullable(),
-	createdAt: string(),
-	updatedAt: string(),
-	format: machineDefinitionFormatSchema.optional()
-});
-/** Result of converting a machine's stored definition to XGraph in place. */
-const machinesConvertResultSchema = object({
-	machine: machineSchema,
-	created: boolean(),
-	version: object({
-		machineVersionId: string(),
-		versionNumber: number(),
-		name: string().nullable()
-	})
-});
-/**
-* A project the caller may fork a machine into, with the version ids a fork
-* can target. `projectVersionIds` is ordered as the provider reports it.
-*/
-const projectDestinationProjectSchema = object({
-	projectId: string(),
-	name: string(),
-	visibility: projectVisibilitySchema,
-	projectVersionIds: array(string())
-});
-/**
-* Fork destinations grouped by owner. The caller's personal projects are one
-* owner alongside each team; `ownerId` is opaque and provider-defined.
-*/
-const projectDestinationSchema = object({
-	ownerId: string(),
-	name: string(),
-	projects: array(projectDestinationProjectSchema)
-});
-/** Result of forking a machine into a new or existing project version. */
-const machinesForkResultSchema = object({
-	machine: machineSchema,
-	projectVersionId: string(),
-	projectId: string()
-});
-/**
-* The version holding a machine's pre-conversion (legacy editor) definition.
-* `versionId` is `null` when the machine has no such version, which is the
-* signal that the legacy editor cannot be re-entered for it.
-*/
-const machineLegacyVersionSchema = object({ versionId: string().nullable() });
-/** Result of restoring a machine's legacy-editor definition. */
-const machinesRestoreLegacyResultSchema = object({
-	machine: machineSchema,
-	version: object({
-		machineVersionId: string(),
-		versionNumber: number(),
-		name: string().nullable()
-	})
-});
-/**
-* Result of restoring a machine to one of its own versions.
-*
-* `capturedVersion` is the new version holding the machine's *pre-restore*
-* definition, so the restore itself is undoable. It is `null` when the restore
-* was a no-op (the machine already held that version's definition), which is
-* the signal that no history row was added.
-*/
-const machinesRestoreVersionResultSchema = object({
-	machine: machineSchema,
-	capturedVersion: machineVersionSummarySchema.nullable()
-});
-const extractedMachinesSchema = object({ machines: array(object({
-	config: record(string(), unknown()),
-	machineIndex: number().int().nonnegative().optional()
-})) });
-const projectsCreateRequestSchema = object({
-	name: string().min(1),
-	visibility: projectVisibilitySchema
-});
-const projectsUpdateRequestSchema = object({
-	name: string().min(1).optional(),
-	description: string().nullable().optional(),
-	visibility: projectVisibilitySchema.optional()
-}).refine((value) => value.name !== void 0 || value.description !== void 0 || value.visibility !== void 0, { message: "At least one of `name`, `description` or `visibility` is required." });
-const machinesCreateRequestSchema = object({
-	projectVersionId: string().min(1),
-	xstateVersion: xstateVersionSchema,
-	name: string().min(1).optional(),
-	definition: unknown().optional()
-});
-const machinesUpdateRequestSchema = object({
-	name: string().min(1).optional(),
-	definition: unknown().optional()
-}).refine((value) => value.name !== void 0 || value.definition !== void 0, { message: "At least one of `name` or `definition` is required." });
-/**
-* `status` is canonical lowercase; providers map it to their own casing.
-* Omitting `definition` snapshots the machine's current definition.
-*/
-const machineVersionsCreateRequestSchema = object({
-	name: string().min(1).optional(),
-	definition: unknown().optional(),
-	status: _enum(["committed", "auto"]).optional(),
-	parentVersionId: string().min(1).optional()
-});
-const machinesConvertRequestSchema = object({
-	definition: xgraphSchema,
-	expectedUpdatedAt: string().min(1),
-	keepOriginalVersion: boolean().optional()
-});
-/**
-* Fork a machine into exactly one target: an existing project version, or a
-* new project to create for it. Both, or neither, is a client bug.
-*/
-const machinesForkRequestSchema = object({
-	targetProjectVersionId: string().min(1).optional(),
-	targetProject: object({
-		name: string().min(1),
-		visibility: projectVisibilitySchema,
-		teamId: string().min(1).optional()
-	}).optional(),
-	machineName: string().min(1).optional(),
-	xstateVersion: xstateVersionSchema.optional()
-}).refine((value) => value.targetProjectVersionId === void 0 !== (value.targetProject === void 0), { message: "Exactly one of `targetProjectVersionId` or `targetProject` is required." });
-const machinesRestoreLegacyRequestSchema = object({
-	versionId: string().min(1).optional(),
-	expectedUpdatedAt: string().min(1),
-	reason: string().optional()
-});
-const machinesRestoreVersionRequestSchema = object({ expectedUpdatedAt: string().min(1).optional() });
-const codeExtractMachinesRequestSchema = object({
-	code: string().min(1),
-	xstateVersion: xstateVersionSchema.optional()
-});
-const authVerifyResponseSchema = verifyResultSchema;
-const projectsListResponseSchema = array(projectSummarySchema);
-const projectsGetResponseSchema = projectSchema;
-const projectsCreateResponseSchema = projectSchema;
-const projectsUpdateResponseSchema = projectSchema;
-const projectsDeleteResponseSchema = object({ projectId: string() });
-const projectsListMachinesResponseSchema = array(projectMachineSummarySchema);
-const projectsDestinationsResponseSchema = array(projectDestinationSchema);
-const machinesCreateResponseSchema = machineSchema;
-const machinesGetResponseSchema = machineSchema;
-const machinesUpdateResponseSchema = machineSchema;
-const machinesGetVersionResponseSchema = machineVersionSchema;
-const machineVersionsListResponseSchema = array(machineVersionSummarySchema);
-const machineVersionsCreateResponseSchema = machineVersionSchema;
-const machinesConvertDefinitionResponseSchema = machinesConvertResultSchema;
-const machinesForkResponseSchema = machinesForkResultSchema;
-const machinesGetLegacyVersionResponseSchema = machineLegacyVersionSchema;
-const machinesRestoreLegacyResponseSchema = machinesRestoreLegacyResultSchema;
-const machinesRestoreVersionResponseSchema = machinesRestoreVersionResultSchema;
-const codeExtractMachinesResponseSchema = extractedMachinesSchema;
-/**
-* Request/response schema pairs keyed by resource capability name. Kept here
-* rather than on the `Capability` metadata entries so that the capability
-* registry stays plain, serialisable data.
-*/
-const resourceOperationSchemas = {
-	"auth.verify": { response: authVerifyResponseSchema },
-	"projects.list": { response: projectsListResponseSchema },
-	"projects.create": {
-		request: projectsCreateRequestSchema,
-		response: projectsCreateResponseSchema
-	},
-	"projects.get": { response: projectsGetResponseSchema },
-	"projects.update": {
-		request: projectsUpdateRequestSchema,
-		response: projectsUpdateResponseSchema
-	},
-	"projects.delete": { response: projectsDeleteResponseSchema },
-	"projects.listMachines": { response: projectsListMachinesResponseSchema },
-	"projects.destinations": { response: projectsDestinationsResponseSchema },
-	"machines.create": {
-		request: machinesCreateRequestSchema,
-		response: machinesCreateResponseSchema
-	},
-	"machines.get": { response: machinesGetResponseSchema },
-	"machines.getVersion": { response: machinesGetVersionResponseSchema },
-	"machines.update": {
-		request: machinesUpdateRequestSchema,
-		response: machinesUpdateResponseSchema
-	},
-	"machines.versions.list": { response: machineVersionsListResponseSchema },
-	"machines.versions.create": {
-		request: machineVersionsCreateRequestSchema,
-		response: machineVersionsCreateResponseSchema
-	},
-	"machines.convertDefinition": {
-		request: machinesConvertRequestSchema,
-		response: machinesConvertDefinitionResponseSchema
-	},
-	"machines.fork": {
-		request: machinesForkRequestSchema,
-		response: machinesForkResponseSchema
-	},
-	"machines.getLegacyVersion": { response: machinesGetLegacyVersionResponseSchema },
-	"machines.restoreLegacy": {
-		request: machinesRestoreLegacyRequestSchema,
-		response: machinesRestoreLegacyResponseSchema
-	},
-	"machines.restoreVersion": {
-		request: machinesRestoreVersionRequestSchema,
-		response: machinesRestoreVersionResponseSchema
-	}
-};
-/** Provider-independent operations implemented by this repository. */
-const codeOperationSchemas = { "code.extractMachines": {
-	request: codeExtractMachinesRequestSchema,
-	response: codeExtractMachinesResponseSchema
-} };
-/** Every owned API operation with a canonical request/response contract. */
-const operationSchemas = {
-	...resourceOperationSchemas,
-	...codeOperationSchemas
-};
-
-//#endregion
-//#region src/studio.ts
-/**
-* Remote client for the owned Stately resource contract (`/api/v1/*`).
-*
-* Every method targets our own routes (never the legacy Registry API), sends
-* JSON bodies with a bearer credential, and validates responses against the
-* canonical Zod schemas from `@statelyai/api-contract`. Responses are canonical
-* values directly: there is no `{ data }` envelope. Errors use the nested
-* envelope `{ error: { code, message, issues?, retryable? } }`.
-*/
-/** Default base URL of the editor/API deployment hosting `/api/v1`. */
-const DEFAULT_STATELY_BASE_URL = "https://editor.stately.ai";
-var StudioApiError = class extends Error {
-	status;
-	/** Canonical resource error code, when the server sent one. */
-	code;
-	issues;
-	retryable;
-	constructor(message, status, options = {}) {
-		super(message);
-		this.name = "StudioApiError";
-		this.status = status;
-		this.code = options.code;
-		this.issues = options.issues;
-		this.retryable = options.retryable;
-	}
-};
-function getFetch(fetchImpl) {
-	const resolvedFetch = fetchImpl ?? globalThis.fetch;
-	if (!resolvedFetch) throw new Error("No fetch implementation available. Pass one via createStatelyClient({ fetch }).");
-	return resolvedFetch;
-}
-function joinApiUrl(baseUrl, path) {
-	return `${baseUrl.replace(/\/+$/, "")}/api/v1${path}`;
-}
-async function parseJson(response) {
-	if (!response.headers.get("content-type")?.includes("application/json")) return null;
-	return response.json().catch(() => null);
-}
-function toApiError(data, status) {
-	const parsed = resourceApiErrorResponseSchema.safeParse(data);
-	if (parsed.success) {
-		const { code, message, issues, retryable } = parsed.data.error;
-		return new StudioApiError(message, status, {
-			code,
-			issues,
-			retryable
-		});
-	}
-	if (typeof data === "object" && data !== null && "error" in data && typeof data.error === "string") return new StudioApiError(data.error, status);
-	return new StudioApiError(`HTTP ${status}`, status);
-}
-function normalizeVisibility(visibility) {
-	return visibility.toLowerCase();
-}
-function normalizeXStateVersion(xstateVersion) {
-	return xstateVersion === void 0 || xstateVersion === 4 ? 5 : xstateVersion;
-}
-function normalizeExtractXStateVersion(xstateVersion) {
-	return xstateVersion === 4 ? 5 : xstateVersion;
-}
-function withMachineAlias(machine) {
-	return {
-		...machine,
-		definition: machine.definition,
-		id: machine.machineId
-	};
-}
-function withProjectAlias(project) {
-	return {
-		...project,
-		id: project.projectVersionId
-	};
-}
-function isCredentialLike(value) {
-	if (typeof value === "string") return true;
-	return typeof value === "object" && value !== null && "type" in value && (value.type === "api_key" || value.type === "oauth");
-}
-function createStatelyClient(options = {}) {
-	const baseUrl = options.baseUrl ?? DEFAULT_STATELY_BASE_URL;
-	const fetchImpl = getFetch(options.fetch);
-	const defaultCredential = options.credential ?? (options.apiKey ? {
-		type: "api_key",
-		token: options.apiKey
-	} : void 0);
-	const defaultAuthMode = options.authMode ?? "auto";
-	async function request(path, init, schema, requestOptions = {}) {
-		const headers = new Headers(init.headers);
-		const authMode = requestOptions.authMode ?? defaultAuthMode;
-		const credential = requestOptions.credential ?? defaultCredential;
-		if (authMode !== "none") {
-			const token = getCredentialToken(credential);
-			if (authMode === "bearer" && (!token || !credential)) throw new StudioApiError("No Stately credential configured. Pass createStatelyClient({ credential }) or use authMode: \"auto\" to let the server decide whether authentication is required.", 401, { code: "unauthenticated" });
-			if (token && credential) headers.set("Authorization", createAuthorizationHeader(credential));
-		}
-		const response = await fetchImpl(joinApiUrl(baseUrl, path), {
-			...init,
-			headers,
-			...requestOptions.signal ? { signal: requestOptions.signal } : {}
-		});
-		const data = await parseJson(response);
-		if (!response.ok) throw toApiError(data, response.status);
-		const parsed = schema.safeParse(data);
-		if (!parsed.success) throw new StudioApiError(`Unexpected response for ${path}: ${parsed.error.message}`, response.status, {
-			code: "internal_error",
-			issues: [...parsed.error.issues]
-		});
-		return parsed.data;
-	}
-	function jsonInit(method, body) {
-		return {
-			method,
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(body)
-		};
-	}
-	const projects = {
-		list(requestOptions) {
-			return request("/projects", { method: "GET" }, projectsListResponseSchema, requestOptions);
-		},
-		create(input, requestOptions) {
-			return request("/projects", jsonInit("POST", {
-				name: input.name,
-				visibility: normalizeVisibility(input.visibility)
-			}), projectSchema, requestOptions).then(withProjectAlias);
-		},
-		get(projectId, requestOptions) {
-			return request(`/projects/${encodeURIComponent(projectId)}`, { method: "GET" }, projectSchema, requestOptions).then(withProjectAlias);
-		},
-		update(projectId, input, requestOptions) {
-			return request(`/projects/${encodeURIComponent(projectId)}`, jsonInit("PATCH", {
-				...input.name !== void 0 ? { name: input.name } : {},
-				...input.description !== void 0 ? { description: input.description } : {},
-				...input.visibility !== void 0 ? { visibility: normalizeVisibility(input.visibility) } : {}
-			}), projectSchema, requestOptions).then(withProjectAlias);
-		},
-		delete(projectId, requestOptions) {
-			return request(`/projects/${encodeURIComponent(projectId)}`, { method: "DELETE" }, projectsDeleteResponseSchema, requestOptions);
-		},
-		listMachines(projectId, requestOptions) {
-			return request(`/projects/${encodeURIComponent(projectId)}/machines`, { method: "GET" }, projectsListMachinesResponseSchema, requestOptions);
-		},
-		async ensure(input, requestOptions) {
-			if (input.matchConnectedRepo !== false) {
-				const match = (await projects.list(requestOptions)).find((candidate) => candidate.name === input.name);
-				if (match) return projects.get(match.projectId, requestOptions);
-			}
-			return projects.create(input, requestOptions);
-		}
-	};
-	const machines = {
-		create(input, requestOptions) {
-			return request("/machines", jsonInit("POST", {
-				projectVersionId: input.projectVersionId,
-				xstateVersion: normalizeXStateVersion(input.xstateVersion),
-				...input.name !== void 0 ? { name: input.name } : {},
-				...input.definition !== void 0 ? { definition: input.definition } : {}
-			}), machineSchema, requestOptions).then((machine) => withMachineAlias(machine));
-		},
-		async createMany(input, requestOptions) {
-			return [await machines.create(input, requestOptions)];
-		},
-		get(machineId, getOptions = {}) {
-			return request(`/machines/${encodeURIComponent(machineId)}`, { method: "GET" }, machineSchema, getOptions).then((machine) => withMachineAlias(machine));
-		},
-		getVersion(machineId, versionId, requestOptions) {
-			return request(`/machines/${encodeURIComponent(machineId)}/versions/${encodeURIComponent(versionId)}`, { method: "GET" }, machineVersionSchema, requestOptions);
-		},
-		update(machineIdOrInput, inputOrOptions, maybeOptions) {
-			const machineId = typeof machineIdOrInput === "string" ? machineIdOrInput : machineIdOrInput.machineId ?? machineIdOrInput.id;
-			if (!machineId) throw new StudioApiError("machines.update requires a machine id.", 400, { code: "bad_request" });
-			const input = (typeof machineIdOrInput === "string" ? inputOrOptions : machineIdOrInput) ?? {};
-			const requestOptions = typeof machineIdOrInput === "string" ? maybeOptions : inputOrOptions;
-			return request(`/machines/${encodeURIComponent(machineId)}`, jsonInit("PATCH", {
-				...input.name !== void 0 ? { name: input.name } : {},
-				...input.definition !== void 0 ? { definition: input.definition } : {}
-			}), machineSchema, requestOptions).then((machine) => withMachineAlias(machine));
-		}
-	};
-	return {
-		auth: { verify(credentialOrOptions, verifyOptions) {
-			return request("/auth/verify", { method: "GET" }, verifyResultSchema, isCredentialLike(credentialOrOptions) ? {
-				...verifyOptions,
-				credential: credentialOrOptions
-			} : credentialOrOptions ?? verifyOptions ?? {});
-		} },
-		projects,
-		machines,
-		code: { extractMachines(codeOrInput, extractOptions = {}) {
-			const input = typeof codeOrInput === "string" ? {
-				code: codeOrInput,
-				xstateVersion: extractOptions.xstateVersion
-			} : codeOrInput;
-			const legacyOptions = extractOptions;
-			const credential = legacyOptions.credential ?? (legacyOptions.apiKey ? {
-				type: "api_key",
-				token: legacyOptions.apiKey
-			} : void 0);
-			return request("/code/extract-machines", jsonInit("POST", {
-				code: input.code,
-				xstateVersion: normalizeExtractXStateVersion(input.xstateVersion)
-			}), extractedMachinesSchema, {
-				...extractOptions,
-				credential
-			});
-		} }
-	};
-}
-
-//#endregion
-export { StudioApiError as n, createStatelyClient as r, DEFAULT_STATELY_BASE_URL as t };