@tailor-platform/sdk 2.0.0-next.2 → 2.0.0-next.3

package/dist/cli/commands/tailordb/migrate/snapshot-types.d.mts

@@ -0,0 +1,202 @@
+//#region src/cli/commands/tailordb/migrate/snapshot-types.d.ts
+/**
+ * Schema snapshot data model for TailorDB migrations.
+ *
+ * Leaf module: these types describe the persisted snapshot format
+ * (XXXX/schema.json) and are shared by snapshot.ts (snapshot management)
+ * and diff-calculator.ts (diff types and formatting) without creating
+ * import cycles between them.
+ */
+/**
+ * Hook configuration in schema snapshot
+ */
+interface SnapshotHook {
+  expr: string;
+}
+/**
+ * Validation configuration in schema snapshot
+ */
+interface SnapshotValidation {
+  script?: {
+    expr: string;
+  };
+  errorMessage: string;
+}
+/**
+ * Serial configuration in schema snapshot
+ */
+interface SnapshotSerial {
+  start: number;
+  maxValue?: number;
+  format?: string;
+}
+/**
+ * Enum value with optional description in schema snapshot
+ */
+interface SnapshotEnumValue {
+  value: string;
+  description?: string;
+}
+/**
+ * Field configuration in schema snapshot
+ */
+interface SnapshotFieldConfig {
+  type: string;
+  required: boolean;
+  array?: boolean;
+  index?: boolean;
+  unique?: boolean;
+  allowedValues?: SnapshotEnumValue[];
+  foreignKey?: boolean;
+  foreignKeyType?: string;
+  foreignKeyField?: string;
+  description?: string;
+  vector?: boolean;
+  hooks?: {
+    create?: SnapshotHook;
+    update?: SnapshotHook;
+  };
+  validate?: SnapshotValidation[];
+  serial?: SnapshotSerial;
+  scale?: number;
+  /** Nested fields (recursive) */
+  fields?: Record<string, SnapshotFieldConfig>;
+}
+/**
+ * Index configuration in schema snapshot
+ */
+interface SnapshotIndexConfig {
+  fields: string[];
+  unique?: boolean;
+}
+/**
+ * Relationship configuration in schema snapshot
+ */
+interface SnapshotRelationship {
+  targetType: string;
+  targetField: string;
+  sourceField: string;
+  isArray: boolean;
+  description: string;
+}
+/**
+ * Field-reference operand in a permission condition. Always an object with
+ * exactly one of `user` / `record` / `newRecord` / `oldRecord` keys.
+ */
+type SnapshotFieldRefOperand = {
+  user: string;
+} | {
+  record: string;
+} | {
+  newRecord: string;
+} | {
+  oldRecord: string;
+};
+/**
+ * Literal value operand (right-hand side of a permission condition). Matches
+ * the SDK-level value operand surface — primitives and their arrays — as
+ * defined in the Zod parser schema (RecordPermissionOperandSchema /
+ * GqlPermissionOperandSchema in parser/service/tailordb/schema.ts).
+ */
+type SnapshotValueOperand = string | boolean | string[] | boolean[];
+/**
+ * Permission operand union. Either a field-ref object or a literal value.
+ */
+type SnapshotPermissionOperand = SnapshotFieldRefOperand | SnapshotValueOperand;
+/**
+ * Permission operators
+ */
+type SnapshotPermissionOperator = "eq" | "ne" | "in" | "nin" | "hasAny" | "nhasAny";
+/**
+ * Permission condition tuple
+ */
+type SnapshotPermissionCondition = readonly [SnapshotPermissionOperand, SnapshotPermissionOperator, SnapshotPermissionOperand];
+/**
+ * Action permission policy
+ */
+interface SnapshotActionPermission {
+  conditions: readonly SnapshotPermissionCondition[];
+  description?: string;
+  permit: "allow" | "deny";
+}
+/**
+ * Record-level permission configuration
+ */
+interface SnapshotRecordPermission {
+  create: readonly SnapshotActionPermission[];
+  read: readonly SnapshotActionPermission[];
+  update: readonly SnapshotActionPermission[];
+  delete: readonly SnapshotActionPermission[];
+}
+/**
+ * GQL permission actions
+ */
+type SnapshotGqlAction = "read" | "create" | "update" | "delete" | "aggregate" | "bulkUpsert" | "all";
+/**
+ * GQL permission policy
+ */
+interface SnapshotGqlPermissionPolicy {
+  conditions: readonly SnapshotPermissionCondition[];
+  actions: readonly SnapshotGqlAction[];
+  permit: "allow" | "deny";
+  description?: string;
+}
+/**
+ * GQL permission configuration
+ */
+type SnapshotGqlPermission = readonly SnapshotGqlPermissionPolicy[];
+/**
+ * Type definition in schema snapshot.
+ * `pluralForm` is always materialized — either set by the SDK user, derived
+ * via inflection at snapshot construction, or backfilled when loading legacy
+ * snapshots in `loadSnapshot`.
+ */
+interface TailorDBSnapshotType {
+  name: string;
+  pluralForm: string;
+  description?: string;
+  fields: Record<string, SnapshotFieldConfig>;
+  settings?: {
+    aggregation?: boolean;
+    bulkUpsert?: boolean;
+    gqlOperations?: {
+      create?: boolean;
+      update?: boolean;
+      delete?: boolean;
+      read?: boolean;
+    };
+    publishEvents?: boolean;
+  };
+  indexes?: Record<string, SnapshotIndexConfig>;
+  files?: Record<string, string>;
+  forwardRelationships?: Record<string, SnapshotRelationship>;
+  backwardRelationships?: Record<string, SnapshotRelationship>;
+  permissions?: {
+    record?: SnapshotRecordPermission;
+    gql?: SnapshotGqlPermission;
+  };
+}
+/**
+ * Schema snapshot - full schema state at a point in time.
+ * Stored as XXXX/schema.json. Defined here (leaf module) so that
+ * snapshot-schema.ts can reference it without importing snapshot.ts.
+ */
+interface SchemaSnapshot {
+  /** Format version for future compatibility */
+  version: number;
+  namespace: string;
+  createdAt: string;
+  types: Record<string, TailorDBSnapshotType>;
+}
+declare const normalizedSchemaSnapshotBrand: unique symbol;
+/**
+ * Schema snapshot normalized to a canonical form for consistent comparison.
+ *
+ * Returned by snapshot creation and loading functions so drift detection stays
+ * stable when local definitions omit defaults that the platform materializes.
+ */
+type NormalizedSchemaSnapshot = SchemaSnapshot & {
+  readonly [normalizedSchemaSnapshotBrand]: true;
+};
+//#endregion
+export { NormalizedSchemaSnapshot, SchemaSnapshot, SnapshotActionPermission, SnapshotEnumValue, SnapshotFieldConfig, SnapshotFieldRefOperand, SnapshotGqlAction, SnapshotGqlPermission, SnapshotGqlPermissionPolicy, SnapshotHook, SnapshotIndexConfig, SnapshotPermissionCondition, SnapshotPermissionOperand, SnapshotPermissionOperator, SnapshotRecordPermission, SnapshotRelationship, SnapshotSerial, SnapshotValidation, SnapshotValueOperand, TailorDBSnapshotType };

package/dist/cli/commands/tailordb/migrate/snapshot.d.mts

@@ -0,0 +1,98 @@
+import { TailorDBType } from "../../../../parser/service/tailordb/types.mjs";
+import { NormalizedSchemaSnapshot, SchemaSnapshot, SnapshotActionPermission, SnapshotEnumValue, SnapshotFieldConfig, SnapshotFieldRefOperand, SnapshotGqlAction, SnapshotGqlPermission, SnapshotGqlPermissionPolicy, SnapshotHook, SnapshotIndexConfig, SnapshotPermissionCondition, SnapshotPermissionOperand, SnapshotPermissionOperator, SnapshotRecordPermission, SnapshotRelationship, SnapshotSerial, SnapshotValidation, SnapshotValueOperand, TailorDBSnapshotType } from "./snapshot-types.mjs";
+import { MigrationDiff } from "./diff-calculator.mjs";
+
+//#region src/cli/commands/tailordb/migrate/snapshot.d.ts
+/**
+ * Initial schema migration number (0000)
+ */
+declare const INITIAL_SCHEMA_NUMBER = 0;
+/**
+ * Migration file names (used within migration directories)
+ */
+declare const SCHEMA_FILE_NAME = "schema.json";
+/** File name for migration diff metadata. */
+declare const DIFF_FILE_NAME = "diff.json";
+/** File name for migration script. */
+declare const MIGRATE_FILE_NAME = "migrate.ts";
+/** File name for generated DB type definitions. */
+declare const DB_TYPES_FILE_NAME = "db.ts";
+/**
+ * Migration file type
+ */
+type MigrationFileType = "schema" | "diff" | "migrate" | "db";
+/**
+ * Get migration directory path for a given number
+ * @param {string} migrationsDir - Base migrations directory path
+ * @param {number} num - Migration number
+ * @returns {string} Full directory path for the migration
+ */
+declare function getMigrationDirPath(migrationsDir: string, num: number): string;
+/**
+ * Get migration file path for a given number and type
+ * @param {string} migrationsDir - Migrations directory path
+ * @param {number} num - Migration number
+ * @param {MigrationFileType} type - File type
+ * @returns {string} Full file path
+ */
+declare function getMigrationFilePath(migrationsDir: string, num: number, type: MigrationFileType): string;
+/**
+ * Create a schema snapshot from local type definitions
+ * @param {Record<string, TailorDBType>} types - Local type definitions
+ * @param {string} namespace - Namespace for the snapshot
+ * @returns {NormalizedSchemaSnapshot} Normalized schema snapshot
+ */
+declare function createSnapshotFromLocalTypes(types: Record<string, TailorDBType>, namespace: string): NormalizedSchemaSnapshot;
+/**
+ * Get all migration directories and their files, sorted by number
+ * @param {string} migrationsDir - Migrations directory path
+ * @returns {Array<{number: number, type: "schema" | "diff", path: string}>} Migration files sorted by number
+ */
+declare function getMigrationFiles(migrationsDir: string): {
+  number: number;
+  type: "schema" | "diff";
+  path: string;
+}[];
+/**
+ * Get the next migration number for a directory
+ * Returns INITIAL_SCHEMA_NUMBER (0) if no migrations exist
+ * @param {string} migrationsDir - Migrations directory path
+ * @returns {number} Next migration number
+ */
+declare function getNextMigrationNumber(migrationsDir: string): number;
+/**
+ * Reconstruct the latest schema snapshot from all migration files
+ * Returns null if no migrations exist
+ * @param {string} migrationsDir - Migrations directory path
+ * @param {number} [maxVersion] - Optional maximum migration version to apply
+ * @returns {NormalizedSchemaSnapshot | null} Reconstructed normalized snapshot or null if no migrations exist
+ */
+declare function reconstructSnapshotFromMigrations(migrationsDir: string, maxVersion?: number): NormalizedSchemaSnapshot | null;
+/**
+ * Get the latest migration number from a directory
+ * Returns 0 if no migrations exist
+ * @param {string} migrationsDir - Migrations directory path
+ * @returns {number} Latest migration number or 0 if no migrations exist
+ */
+declare function getLatestMigrationNumber(migrationsDir: string): number;
+/**
+ * Compare two snapshots and generate a diff
+ * @param {SchemaSnapshot} previous - Previous schema snapshot
+ * @param {SchemaSnapshot} current - Current schema snapshot
+ * @returns {MigrationDiff} Migration diff between snapshots
+ */
+declare function compareSnapshots(previous: SchemaSnapshot, current: SchemaSnapshot): MigrationDiff;
+/**
+ * Compare a snapshot against canonical TailorDBSnapshotType-shaped local types.
+ * Callers are expected to pre-convert TailorDBService.types to TailorDBSnapshotType via
+ * `createSnapshotType`. As a safety net, `compareSnapshots` re-runs idempotent
+ * normalization on both sides, so a caller that forgets will still get correct
+ * comparisons (no silent false drift).
+ * @param {SchemaSnapshot} snapshot - Schema snapshot to compare against
+ * @param {Record<string, TailorDBSnapshotType>} localTypes - Local snapshot-shaped types
+ * @param {string} namespace - Namespace for comparison
+ * @returns {MigrationDiff} Migration diff
+ */
+declare function compareLocalTypesWithSnapshot(snapshot: SchemaSnapshot, localTypes: Record<string, TailorDBSnapshotType>, namespace: string): MigrationDiff;
+//#endregion
+export { DB_TYPES_FILE_NAME, DIFF_FILE_NAME, INITIAL_SCHEMA_NUMBER, MIGRATE_FILE_NAME, MigrationFileType, type NormalizedSchemaSnapshot, SCHEMA_FILE_NAME, type SchemaSnapshot, type SnapshotFieldConfig, type TailorDBSnapshotType, compareLocalTypesWithSnapshot, compareSnapshots, createSnapshotFromLocalTypes, getLatestMigrationNumber, getMigrationDirPath, getMigrationFilePath, getMigrationFiles, getNextMigrationNumber, reconstructSnapshotFromMigrations };

package/dist/cli/commands/tailordb/migrate/types.d.mts

@@ -0,0 +1,7 @@
+//#region src/cli/commands/tailordb/migrate/types.d.ts
+/**
+ * Label key for storing migration state in TailorDB Service metadata
+ */
+declare const MIGRATION_LABEL_KEY = "sdk-migration";
+//#endregion
+export { MIGRATION_LABEL_KEY };

package/dist/cli/commands/tailordb/truncate.d.mts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+//#region src/cli/commands/tailordb/truncate.d.ts
+interface TruncateOptions {
+  workspaceId?: string;
+  profile?: string;
+  configPath?: string;
+  all?: boolean;
+  namespace?: string;
+  types?: string[];
+}
+/**
+ * Truncate TailorDB data based on the given options.
+ * @param options - Truncate options (all, namespace, or types)
+ * @returns Promise that resolves when truncation completes
+ */
+declare function truncate(options?: TruncateOptions): Promise<void>;
+//#endregion
+export { TruncateOptions, truncate };

package/dist/cli/commands/workflow/executions.d.mts

@@ -0,0 +1,75 @@
+import { Order } from "../../shared/args.mjs";
+import { WorkflowExecutionInfo, WorkflowJobExecutionInfo } from "./transform.mjs";
+import { WorkflowWaitUntil } from "./status.mjs";
+import { WorkflowWaitResult } from "./waiter.mjs";
+import { z } from "zod";
+
+//#region src/cli/commands/workflow/executions.d.ts
+type WorkflowLike = {
+  name: string;
+};
+type ListWorkflowExecutionsTypedOptions<W extends WorkflowLike = WorkflowLike> = {
+  workflow?: W;
+  status?: string;
+  workspaceId?: string;
+  profile?: string;
+  order?: Order;
+  limit?: number;
+};
+/**
+ * @deprecated Use ListWorkflowExecutionsTypedOptions instead.
+ */
+interface ListWorkflowExecutionsOptions {
+  workspaceId?: string;
+  profile?: string;
+  workflowName?: string;
+  status?: string;
+  order?: Order;
+  limit?: number;
+}
+interface GetWorkflowExecutionOptions {
+  executionId: string;
+  workspaceId?: string;
+  profile?: string;
+  interval?: number;
+  timeout?: number;
+  until?: WorkflowWaitUntil;
+  logs?: boolean;
+}
+interface WorkflowExecutionDetailInfo extends WorkflowExecutionInfo {
+  jobDetails?: (WorkflowJobExecutionInfo & {
+    logs?: string;
+    result?: string;
+  })[];
+}
+interface WorkflowExecutionWaitInfo extends WorkflowExecutionDetailInfo {
+  statusClass: WorkflowWaitResult["statusClass"];
+  elapsedMs: number;
+  attempts: number;
+  timedOut: boolean;
+  lastError: string | null;
+}
+interface GetWorkflowExecutionResult {
+  execution: WorkflowExecutionDetailInfo;
+  wait: () => Promise<WorkflowExecutionWaitInfo>;
+}
+/**
+ * List workflow executions with optional filters.
+ *
+ * Returns at most `options.limit` items. When `limit` is omitted or 0 the
+ * function pages through every execution. The CLI caps this at 50 by
+ * default via `pagedLogArgs`; programmatic callers that want the same
+ * cap should pass `limit: 50` explicitly.
+ * @param options - Workflow execution listing options
+ * @returns List of workflow executions
+ */
+declare function listWorkflowExecutions<W extends WorkflowLike>(options?: ListWorkflowExecutionsTypedOptions<W>): Promise<WorkflowExecutionInfo[]>;
+declare function listWorkflowExecutions(options?: ListWorkflowExecutionsOptions): Promise<WorkflowExecutionInfo[]>;
+/**
+ * Get a single workflow execution with optional logs.
+ * @param options - Workflow execution lookup options
+ * @returns Workflow execution with optional logs
+ */
+declare function getWorkflowExecution(options: GetWorkflowExecutionOptions): Promise<GetWorkflowExecutionResult>;
+//#endregion
+export { GetWorkflowExecutionOptions, GetWorkflowExecutionResult, ListWorkflowExecutionsOptions, ListWorkflowExecutionsTypedOptions, WorkflowExecutionDetailInfo, WorkflowExecutionWaitInfo, getWorkflowExecution, listWorkflowExecutions };

package/dist/cli/commands/workflow/get.d.mts

@@ -0,0 +1,29 @@
+import { WorkflowInfo } from "./transform.mjs";
+import { z } from "zod";
+
+//#region src/cli/commands/workflow/get.d.ts
+type WorkflowLike = {
+  name: string;
+};
+type GetWorkflowTypedOptions<W extends WorkflowLike = WorkflowLike> = {
+  workflow: W;
+  workspaceId?: string;
+  profile?: string;
+};
+/**
+ * @deprecated Use GetWorkflowTypedOptions instead.
+ */
+interface GetWorkflowOptions {
+  name: string;
+  workspaceId?: string;
+  profile?: string;
+}
+/**
+ * Get a workflow by name and return CLI-friendly info.
+ * @param options - Workflow lookup options
+ * @returns Workflow information
+ */
+declare function getWorkflow<W extends WorkflowLike>(options: GetWorkflowTypedOptions<W>): Promise<WorkflowInfo>;
+declare function getWorkflow(options: GetWorkflowOptions): Promise<WorkflowInfo>;
+//#endregion
+export { GetWorkflowOptions, GetWorkflowTypedOptions, getWorkflow };

package/dist/cli/commands/workflow/list.d.mts

@@ -0,0 +1,19 @@
+import { Order } from "../../shared/args.mjs";
+import { WorkflowListInfo } from "./transform.mjs";
+import { z } from "zod";
+
+//#region src/cli/commands/workflow/list.d.ts
+interface ListWorkflowsOptions {
+  workspaceId?: string;
+  profile?: string;
+  order?: Order;
+  limit?: number;
+}
+/**
+ * List workflows in the workspace and return CLI-friendly info.
+ * @param options - Workflow listing options
+ * @returns List of workflows
+ */
+declare function listWorkflows(options?: ListWorkflowsOptions): Promise<WorkflowListInfo[]>;
+//#endregion
+export { ListWorkflowsOptions, listWorkflows };

package/dist/cli/commands/workflow/resume.d.mts

@@ -0,0 +1,23 @@
+import { WorkflowWaitResult } from "./waiter.mjs";
+import { WaitOptions } from "./start.mjs";
+import { z } from "zod";
+
+//#region src/cli/commands/workflow/resume.d.ts
+interface ResumeWorkflowOptions {
+  executionId: string;
+  workspaceId?: string;
+  profile?: string;
+  interval?: number;
+}
+interface ResumeWorkflowResultWithWait {
+  executionId: string;
+  wait: (options?: WaitOptions) => Promise<WorkflowWaitResult>;
+}
+/**
+ * Resume a suspended workflow execution and return a handle to wait for completion.
+ * @param options - Resume options
+ * @returns Resume result with wait helper
+ */
+declare function resumeWorkflow(options: ResumeWorkflowOptions): Promise<ResumeWorkflowResultWithWait>;
+//#endregion
+export { ResumeWorkflowOptions, ResumeWorkflowResultWithWait, resumeWorkflow };

package/dist/cli/commands/workflow/start.d.mts

@@ -0,0 +1,61 @@
+import { WorkflowWaitUntil } from "./status.mjs";
+import { WorkflowWaitResult } from "./waiter.mjs";
+import { Jsonifiable } from "type-fest";
+import { z } from "zod";
+import { MachineUserName } from "@tailor-platform/sdk";
+
+//#region src/cli/commands/workflow/start.d.ts
+type WorkflowLike = {
+  name: string;
+  mainJob: {
+    body: unknown;
+  };
+};
+type WorkflowInput<W extends WorkflowLike> = W extends WorkflowLike ? W["mainJob"]["body"] extends ((...args: infer Args) => unknown) ? Args[0] : never : never;
+type StartWorkflowArgOptionForSingleWorkflow<W extends WorkflowLike> = WorkflowLike extends W ? {
+  arg?: Jsonifiable;
+} : undefined extends WorkflowInput<W> ? {
+  arg?: WorkflowInput<W>;
+} : {
+  arg: WorkflowInput<W>;
+};
+type StartWorkflowArgOption<W extends WorkflowLike> = W extends WorkflowLike ? StartWorkflowArgOptionForSingleWorkflow<W> : never;
+/**
+ * @deprecated Use StartWorkflowTypedOptions instead.
+ */
+interface StartWorkflowOptions {
+  name: string;
+  machineUser?: string;
+  arg?: Jsonifiable;
+  workspaceId?: string;
+  profile?: string;
+  configPath?: string;
+  interval?: number;
+}
+type StartWorkflowTypedBaseOptions<W extends WorkflowLike> = {
+  workflow: W;
+  invoker: MachineUserName;
+  workspaceId?: string;
+  profile?: string;
+  configPath?: string;
+  interval?: number;
+};
+type StartWorkflowTypedOptions<W extends WorkflowLike = WorkflowLike> = W extends WorkflowLike ? StartWorkflowTypedBaseOptions<W> & StartWorkflowArgOption<W> : never;
+interface WaitOptions {
+  showProgress?: boolean;
+  timeout?: number;
+  until?: WorkflowWaitUntil;
+}
+interface StartWorkflowResultWithWait {
+  executionId: string;
+  wait: (options?: WaitOptions) => Promise<WorkflowWaitResult>;
+}
+/**
+ * Start a workflow and return a handle to wait for completion.
+ * @param options - Start options
+ * @returns Start result with wait helper
+ */
+declare function startWorkflow<W extends WorkflowLike>(options: StartWorkflowTypedOptions<W>): Promise<StartWorkflowResultWithWait>;
+declare function startWorkflow(options: StartWorkflowOptions): Promise<StartWorkflowResultWithWait>;
+//#endregion
+export { StartWorkflowOptions, StartWorkflowResultWithWait, StartWorkflowTypedOptions, WaitOptions, startWorkflow };

package/dist/cli/commands/workflow/status.d.mts

@@ -0,0 +1,5 @@
+//#region src/cli/commands/workflow/status.d.ts
+type WorkflowWaitUntil = "success" | "suspended" | "terminal";
+type WorkflowExecutionStatusClass = "success" | "suspended" | "failure" | "transient";
+//#endregion
+export { WorkflowExecutionStatusClass, WorkflowWaitUntil };

package/dist/cli/commands/workflow/transform.d.mts

@@ -0,0 +1,33 @@
+//#region src/cli/commands/workflow/transform.d.ts
+interface WorkflowListInfo {
+  name: string;
+  mainJob: string;
+  jobFunctions: number;
+  updatedAt: Date | null;
+}
+interface WorkflowInfo {
+  name: string;
+  id: string;
+  mainJob: string;
+  jobFunctions: Record<string, string>;
+  createdAt: Date | null;
+  updatedAt: Date | null;
+}
+interface WorkflowJobExecutionInfo {
+  id: string;
+  stackedJobName: string;
+  status: string;
+  executionId: string;
+  startedAt: Date | null;
+  finishedAt: Date | null;
+}
+interface WorkflowExecutionInfo {
+  id: string;
+  workflowName: string;
+  status: string;
+  jobExecutions: number;
+  startedAt: Date | null;
+  finishedAt: Date | null;
+}
+//#endregion
+export { WorkflowExecutionInfo, WorkflowInfo, WorkflowJobExecutionInfo, WorkflowListInfo };

package/dist/cli/commands/workflow/wait.d.mts

@@ -0,0 +1,16 @@
+import { WaitWorkflowExecutionOptions, WorkflowWaitResult } from "./waiter.mjs";
+import { getWorkflowExecution } from "./executions.mjs";
+import { z } from "zod";
+
+//#region src/cli/commands/workflow/wait.d.ts
+interface WorkflowWaitOutput extends WorkflowWaitResult {
+  jobDetails?: Awaited<ReturnType<typeof getWorkflowExecution>>["execution"]["jobDetails"];
+}
+/**
+ * Wait for an existing workflow execution by ID.
+ * @param options - Workflow wait options
+ * @returns Workflow wait result
+ */
+declare function waitWorkflowExecution(options: WaitWorkflowExecutionOptions): Promise<WorkflowWaitResult>;
+//#endregion
+export { WorkflowWaitOutput, waitWorkflowExecution };

package/dist/cli/commands/workflow/waiter.d.mts

@@ -0,0 +1,23 @@
+import { WorkflowExecutionInfo } from "./transform.mjs";
+import { WorkflowExecutionStatusClass, WorkflowWaitUntil } from "./status.mjs";
+
+//#region src/cli/commands/workflow/waiter.d.ts
+interface WaitWorkflowExecutionOptions {
+  executionId: string;
+  workspaceId?: string;
+  profile?: string;
+  interval?: number;
+  timeout?: number;
+  until?: WorkflowWaitUntil;
+  showProgress?: boolean;
+  trackJobs?: boolean;
+}
+interface WorkflowWaitResult extends WorkflowExecutionInfo {
+  statusClass: WorkflowExecutionStatusClass | "unknown";
+  elapsedMs: number;
+  attempts: number;
+  timedOut: boolean;
+  lastError: string | null;
+}
+//#endregion
+export { WaitWorkflowExecutionOptions, WorkflowWaitResult };

package/dist/cli/commands/workspace/app/health.d.mts

@@ -0,0 +1,18 @@
+import { AppHealthInfo } from "./transform.mjs";
+import { z } from "zod";
+
+//#region src/cli/commands/workspace/app/health.d.ts
+declare const healthOptionsSchema: z.ZodObject<{
+  workspaceId: z.ZodOptional<z.ZodUUID>;
+  profile: z.ZodOptional<z.ZodString>;
+  name: z.ZodString;
+}, z.core.$strip>;
+type HealthOptions = z.input<typeof healthOptionsSchema>;
+/**
+ * Get application schema health status.
+ * @param options - Health check options
+ * @returns Application health information
+ */
+declare function getAppHealth(options: HealthOptions): Promise<AppHealthInfo>;
+//#endregion
+export { HealthOptions, getAppHealth };

package/dist/cli/commands/workspace/app/list.d.mts

@@ -0,0 +1,22 @@
+import { AppInfo } from "./transform.mjs";
+import { z } from "zod";
+
+//#region src/cli/commands/workspace/app/list.d.ts
+declare const listAppsOptionsSchema: z.ZodObject<{
+  workspaceId: z.ZodOptional<z.ZodUUID>;
+  profile: z.ZodOptional<z.ZodString>;
+  order: z.ZodOptional<z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>>;
+  limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+type ListAppsOptions = z.input<typeof listAppsOptionsSchema>;
+/**
+ * List applications in a workspace with an optional order and limit.
+ * @param options - Application listing options
+ * @returns List of applications
+ */
+declare function listApps(options: ListAppsOptions): Promise<AppInfo[]>;
+//#endregion
+export { ListAppsOptions, listApps };