@statelyai/sdk 0.14.2 → 0.15.0

package/dist/studio-Da5pyxv6.d.mts

@@ -0,0 +1,303 @@
+import { A as $strip, C as ZodObject, D as ZodUnion, E as ZodString, O as ZodUnknown, S as ZodNumber, T as ZodRecord, b as ZodLiteral, k as output, v as ZodArray, w as ZodOptional, x as ZodNullable, y as ZodEnum } from "./index-ag6K2iAS.mjs";
+import { n as StatelyCredential, t as StatelyAuthMode } from "./auth-2Thaw42j.mjs";
+
+//#region ../api-contract/dist/errors.d.mts
+/**
+ * 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.
+ */
+declare const resourceErrorCodeSchema: ZodEnum<{
+  bad_request: "bad_request";
+  unauthenticated: "unauthenticated";
+  forbidden: "forbidden";
+  not_found: "not_found";
+  conflict: "conflict";
+  payload_too_large: "payload_too_large";
+  rate_limited: "rate_limited";
+  capability_disabled: "capability_disabled";
+  upstream_error: "upstream_error";
+  internal_error: "internal_error";
+}>;
+type ResourceErrorCode = output<typeof resourceErrorCodeSchema>;
+/** Factory, matching `createApiErrorResponseSchema`, for per-route OpenAPI components. */
+//#endregion
+//#region ../api-contract/dist/resources.d.mts
+//#region src/resources.d.ts
+/**
+ * XState major versions the editor targets (see
+ * `packages/editor/src/formats/xstate.ts`).
+ */
+declare const xstateVersionSchema: ZodUnion<readonly [ZodLiteral<5>, ZodLiteral<6>]>;
+type XStateVersion = output<typeof xstateVersionSchema>;
+declare const projectVisibilitySchema: ZodEnum<{
+  public: "public";
+  unlisted: "unlisted";
+  private: "private";
+}>;
+type ProjectVisibility = output<typeof projectVisibilitySchema>;
+declare const verifyResultSchema: ZodObject<{
+  valid: ZodLiteral<true>;
+  tokenScope: ZodEnum<{
+    user: "user";
+    project: "project";
+  }>;
+}, $strip>;
+type VerifyResult = output<typeof verifyResultSchema>;
+declare const projectSummarySchema: ZodObject<{
+  projectId: ZodString;
+  projectVersionId: ZodString;
+  name: ZodString;
+  description: ZodNullable<ZodString>;
+  visibility: ZodEnum<{
+    public: "public";
+    unlisted: "unlisted";
+    private: "private";
+  }>;
+  createdAt: ZodString;
+  updatedAt: ZodString;
+}, $strip>;
+type ProjectSummary = output<typeof projectSummarySchema>;
+declare const projectSchema: ZodObject<{
+  projectId: ZodString;
+  projectVersionId: ZodString;
+  name: ZodString;
+  description: ZodNullable<ZodString>;
+  visibility: ZodEnum<{
+    public: "public";
+    unlisted: "unlisted";
+    private: "private";
+  }>;
+  createdAt: ZodString;
+  updatedAt: ZodString;
+  rootMachineId: ZodNullable<ZodString>;
+  machines: ZodArray<ZodObject<{
+    machineId: ZodString;
+  }, $strip>>;
+}, $strip>;
+type Project = output<typeof projectSchema>;
+/**
+ * `name` is optional: the Registry project envelope only returns machine ids.
+ * Providers that can supply names cheaply should.
+ */
+declare const projectMachineSummarySchema: ZodObject<{
+  machineId: ZodString;
+  name: ZodOptional<ZodString>;
+}, $strip>;
+type ProjectMachineSummary = output<typeof projectMachineSummarySchema>;
+declare const machineSchema: ZodObject<{
+  machineId: ZodString;
+  name: ZodString;
+  projectId: ZodOptional<ZodString>;
+  projectVersionId: ZodString;
+  definition: ZodUnknown;
+  createdAt: ZodOptional<ZodString>;
+  updatedAt: ZodOptional<ZodString>;
+}, $strip>;
+type Machine = output<typeof machineSchema>;
+declare const machineVersionSchema: ZodObject<{
+  machineVersionId: ZodString;
+  machineId: ZodString;
+  versionNumber: ZodNumber;
+  name: ZodString;
+  definition: ZodUnknown;
+  createdAt: ZodString;
+  updatedAt: ZodString;
+}, $strip>;
+type MachineVersion = output<typeof machineVersionSchema>;
+declare const extractedMachinesSchema: ZodObject<{
+  machines: ZodArray<ZodObject<{
+    config: ZodRecord<ZodString, ZodUnknown>;
+  }, $strip>>;
+}, $strip>;
+type ExtractedMachines = output<typeof extractedMachinesSchema>;
+//#endregion
+//#region src/studio.d.ts
+/** Default base URL of the editor/API deployment hosting `/api/v1`. */
+declare const DEFAULT_STATELY_BASE_URL = "https://editor.stately.ai";
+interface StudioClientOptions {
+  /** Editor/API base URL. Defaults to {@link DEFAULT_STATELY_BASE_URL}. */
+  baseUrl?: string;
+  credential?: StatelyCredential;
+  /** @deprecated Use `credential: { type: 'api_key', token }`. */
+  apiKey?: string;
+  authMode?: StatelyAuthMode;
+  fetch?: typeof fetch;
+}
+/** Per-call options accepted by every client method. */
+interface StudioRequestOptions {
+  signal?: AbortSignal;
+  credential?: StatelyCredential | string | null;
+  authMode?: StatelyAuthMode;
+}
+/** @deprecated Use {@link VerifyResult}. */
+type VerifyApiKeyResponse = VerifyResult;
+/** @deprecated Visibility is lowercase in the canonical contract. */
+type LegacyProjectVisibility = 'Public' | 'Private' | 'Unlisted';
+type RepoType = 'GITHUB';
+/**
+ * @deprecated The canonical contract does not model connected repositories.
+ * Accepted by {@link StudioClient.projects.ensure} for compatibility only.
+ */
+interface ConnectedRepo {
+  id?: string;
+  type?: RepoType;
+  url: string;
+  owner: string;
+  repo: string;
+  branch: string;
+  treeSha: string;
+  autoSync?: boolean;
+  pathForNewFiles?: string;
+  selectedPaths?: string[];
+  lastSyncedAt?: string;
+}
+/** @deprecated Use {@link ProjectMachineSummary}. */
+type ProjectMachine = ProjectMachineSummary;
+/**
+ * @deprecated Use {@link Project}. Retained so existing consumers keep
+ * compiling; the extra members are SDK-only compatibility aliases.
+ */
+type ProjectData = Project & {
+  /** @deprecated Use `projectVersionId`. */id?: string;
+  keywords?: string[];
+  connectedRepo?: ConnectedRepo | null;
+};
+/** @deprecated Use {@link ExtractedMachines}`['machines'][number]`. */
+interface ExtractedMachine {
+  config: Record<string, unknown>;
+  id?: string;
+  setupConfig?: Record<string, unknown>;
+  implementations?: Record<string, unknown>;
+  _type?: 'setup.createMachine' | 'createMachine';
+}
+/** @deprecated Use {@link ExtractedMachines}. */
+interface ExtractMachinesResponse {
+  machines: ExtractedMachine[];
+  /** @deprecated Extraction failures now reject with a {@link StudioApiError}. */
+  error?: string;
+}
+/**
+ * Canonical {@link Machine} with the deprecated `id` alias the previous SDK
+ * returned. `id` always equals `machineId`.
+ */
+type StudioMachineRecord<TDefinition = unknown> = Omit<Machine, 'definition'> & {
+  definition: TDefinition; /** @deprecated Use `machineId`. */
+  id: string;
+};
+interface CreateProjectInput {
+  name: string;
+  visibility: ProjectVisibility | LegacyProjectVisibility;
+  /** @deprecated Not part of `projects.create`; use `projects.update`. */
+  description?: string;
+  /** @deprecated Keywords are not part of the canonical contract. */
+  keywords?: string[];
+  /** @deprecated Connected repositories are not part of the canonical contract. */
+  repo?: ConnectedRepo;
+}
+interface UpdateProjectInput {
+  name?: string;
+  description?: string | null;
+  visibility?: ProjectVisibility | LegacyProjectVisibility;
+}
+interface EnsureProjectInput extends CreateProjectInput {
+  /** @deprecated Repository matching is best-effort; see `projects.ensure`. */
+  matchConnectedRepo?: boolean;
+}
+interface CreateMachineInput<TDefinition = unknown> {
+  projectVersionId: string;
+  /**
+   * Defaults to `5`. Legacy XState `4` is normalized to `5`; the canonical
+   * contract only accepts `5 | 6`.
+   */
+  xstateVersion?: XStateVersion | 4;
+  name?: string;
+  definition?: TDefinition;
+  /** @deprecated Templates are not part of the canonical contract; ignored. */
+  template?: 'blank' | 'starter';
+}
+/** @deprecated Use {@link CreateMachineInput}. */
+type CreateMachineFromDefinitionInput<TDefinition = unknown> = CreateMachineInput<TDefinition>;
+/** @deprecated Use {@link CreateMachineInput}. */
+type CreateMachineFromTemplateInput = CreateMachineInput;
+/** @deprecated Templates are not part of the canonical contract. */
+type CreateMachineTemplate = 'blank' | 'starter';
+interface UpdateMachineInput<TDefinition = unknown> {
+  name?: string;
+  definition?: TDefinition;
+}
+/** @deprecated Pass the machine id as the first argument instead. */
+interface LegacyUpdateMachineInput<TDefinition = unknown> extends UpdateMachineInput<TDefinition> {
+  /** @deprecated Use `machineId`. */
+  id?: string;
+  machineId?: string;
+}
+interface ExtractMachinesInput {
+  code: string;
+  /** Optional override. Omit to infer the source profile structurally. */
+  xstateVersion?: XStateVersion | 4;
+}
+/** @deprecated Options object of the previous `code.extractMachines(code, options)`. */
+interface LegacyExtractMachinesOptions extends StudioRequestOptions {
+  /** @deprecated Use `credential`. */
+  apiKey?: string | null;
+  xstateVersion?: XStateVersion | 4;
+}
+/** @deprecated `machines.get` no longer resolves versions; use `machines.getVersion`. */
+interface GetMachineOptions extends StudioRequestOptions {
+  /** @deprecated Use `machines.getVersion(machineId, versionId)`. */
+  version?: string;
+}
+interface StudioApiErrorOptions {
+  code?: ResourceErrorCode;
+  issues?: unknown[];
+  retryable?: boolean;
+}
+declare class StudioApiError extends Error {
+  readonly status: number;
+  /** Canonical resource error code, when the server sent one. */
+  readonly code?: ResourceErrorCode;
+  readonly issues?: unknown[];
+  readonly retryable?: boolean;
+  constructor(message: string, status: number, options?: StudioApiErrorOptions);
+}
+interface StudioClient {
+  auth: {
+    /** `GET /api/v1/auth/verify` */verify(credentialOrOptions?: StatelyCredential | string | StudioRequestOptions, options?: StudioRequestOptions): Promise<VerifyResult>;
+  };
+  projects: {
+    /** `GET /api/v1/projects` */list(options?: StudioRequestOptions): Promise<ProjectSummary[]>; /** `POST /api/v1/projects` */
+    create(input: CreateProjectInput, options?: StudioRequestOptions): Promise<ProjectData>; /** `GET /api/v1/projects/:projectId` */
+    get(projectId: string, options?: StudioRequestOptions): Promise<ProjectData>; /** `PATCH /api/v1/projects/:projectId` */
+    update(projectId: string, input: UpdateProjectInput, options?: StudioRequestOptions): Promise<ProjectData>; /** `DELETE /api/v1/projects/:projectId` (SDK-only surface) */
+    delete(projectId: string, options?: StudioRequestOptions): Promise<{
+      projectId: string;
+    }>; /** `GET /api/v1/projects/:projectId/machines` */
+    listMachines(projectId: string, options?: StudioRequestOptions): Promise<ProjectMachineSummary[]>;
+    /**
+     * Client workflow (not a route): find an existing project matching the
+     * input, otherwise create one. Composed of `projects.list`,
+     * `projects.get` and `projects.create`.
+     */
+    ensure(input: EnsureProjectInput, options?: StudioRequestOptions): Promise<ProjectData>;
+  };
+  machines: {
+    /** `POST /api/v1/machines` */create<TDefinition = unknown>(input: CreateMachineInput<TDefinition>, options?: StudioRequestOptions): Promise<StudioMachineRecord<TDefinition>>;
+    /**
+     * @deprecated Singular semantics: creates one machine and returns it in a
+     * single-element array. Use `machines.create`.
+     */
+    createMany<TDefinition = unknown>(input: CreateMachineInput<TDefinition>, options?: StudioRequestOptions): Promise<Array<StudioMachineRecord<TDefinition>>>; /** `GET /api/v1/machines/:machineId` */
+    get<TDefinition = unknown>(machineId: string, options?: GetMachineOptions): Promise<StudioMachineRecord<TDefinition>>; /** `GET /api/v1/machines/:machineId/versions/:versionId` */
+    getVersion(machineId: string, versionId: string, options?: StudioRequestOptions): Promise<MachineVersion>; /** `PATCH /api/v1/machines/:machineId` */
+    update<TDefinition = unknown>(machineId: string, input: UpdateMachineInput<TDefinition>, options?: StudioRequestOptions): Promise<StudioMachineRecord<TDefinition>>; /** @deprecated Pass the machine id as the first argument. */
+    update<TDefinition = unknown>(input: LegacyUpdateMachineInput<TDefinition>, options?: StudioRequestOptions): Promise<StudioMachineRecord<TDefinition>>;
+  };
+  code: {
+    /** `POST /api/v1/code/extract-machines` */extractMachines(input: ExtractMachinesInput, options?: StudioRequestOptions): Promise<ExtractedMachines>; /** @deprecated Pass `{ code, xstateVersion }`. */
+    extractMachines(code: string, options?: LegacyExtractMachinesOptions): Promise<ExtractedMachines>;
+  };
+}
+declare function createStatelyClient(options?: StudioClientOptions): StudioClient;
+//#endregion
+export { Machine as A, StudioMachineRecord as C, VerifyApiKeyResponse as D, UpdateProjectInput as E, ProjectVisibility as F, VerifyResult as I, XStateVersion as L, Project as M, ProjectMachineSummary as N, createStatelyClient as O, ProjectSummary as P, ResourceErrorCode as R, StudioClientOptions as S, UpdateMachineInput as T, ProjectMachine as _, CreateMachineTemplate as a, StudioApiErrorOptions as b, EnsureProjectInput as c, ExtractedMachine as d, GetMachineOptions as f, ProjectData as g, LegacyUpdateMachineInput as h, CreateMachineInput as i, MachineVersion as j, ExtractedMachines as k, ExtractMachinesInput as l, LegacyProjectVisibility as m, CreateMachineFromDefinitionInput as n, CreateProjectInput as o, LegacyExtractMachinesOptions as p, CreateMachineFromTemplateInput as r, DEFAULT_STATELY_BASE_URL as s, ConnectedRepo as t, ExtractMachinesResponse as u, RepoType as v, StudioRequestOptions as w, StudioClient as x, StudioApiError as y };