@tailor-platform/sdk 2.0.0-next.0 → 2.0.0-next.10

package/dist/cli/commands/tailordb/migrate/diff-calculator.d.mts

@@ -0,0 +1,246 @@
+import { SnapshotFieldConfig, SnapshotGqlPermission, SnapshotIndexConfig, SnapshotRecordPermission, SnapshotRelationship, TailorDBSnapshotType } from "./snapshot-types.mjs";
+//#region src/cli/commands/tailordb/migrate/diff-calculator.d.ts
+/**
+ * Properties shared by all diff change variants
+ */
+interface DiffChangeBase {
+  typeName: string;
+  reason?: string;
+}
+/**
+ * Type-level settings patch carried by legacy `type_modified` changes.
+ * Current SDK versions no longer produce this kind, but persisted
+ * diff.json files written by older versions may still contain it.
+ */
+interface TypeSettingsPatch {
+  indexes?: Record<string, SnapshotIndexConfig>;
+  files?: Record<string, string>;
+}
+/** Type-level settings and metadata state used by current diffs. */
+interface SnapshotTypeSettingsState {
+  description?: string;
+  pluralForm: string;
+  settings?: TailorDBSnapshotType["settings"];
+}
+/**
+ * Permission state carried by `permission_modified` changes.
+ */
+interface SnapshotPermissionState {
+  recordPermission?: SnapshotRecordPermission;
+  gqlPermission?: SnapshotGqlPermission;
+}
+/** A new type was added to the schema. */
+interface TypeAddedChange extends DiffChangeBase {
+  kind: "type_added";
+  after: TailorDBSnapshotType;
+}
+/** An existing type was removed from the schema. */
+interface TypeRemovedChange extends DiffChangeBase {
+  kind: "type_removed";
+  before: TailorDBSnapshotType;
+}
+/**
+ * Legacy type-level settings change. Kept for backward compatibility with
+ * diff.json files written by older SDK versions; `before`/`after` may be
+ * absent in those files, hence optional.
+ */
+interface TypeModifiedChange extends DiffChangeBase {
+  kind: "type_modified";
+  before?: TypeSettingsPatch;
+  after?: TypeSettingsPatch;
+}
+/** Type-level settings or metadata changed. */
+interface TypeSettingsModifiedChange extends DiffChangeBase {
+  kind: "type_settings_modified";
+  before: SnapshotTypeSettingsState;
+  after: SnapshotTypeSettingsState;
+}
+/** A field was added to a type. */
+interface FieldAddedChange extends DiffChangeBase {
+  kind: "field_added";
+  fieldName: string;
+  after: SnapshotFieldConfig;
+}
+/** A field was removed from a type. */
+interface FieldRemovedChange extends DiffChangeBase {
+  kind: "field_removed";
+  fieldName: string;
+  before: SnapshotFieldConfig;
+}
+/** A field configuration was modified. */
+interface FieldModifiedChange extends DiffChangeBase {
+  kind: "field_modified";
+  fieldName: string;
+  before: SnapshotFieldConfig;
+  after: SnapshotFieldConfig;
+}
+/** An index was added to a type. */
+interface IndexAddedChange extends DiffChangeBase {
+  kind: "index_added";
+  indexName: string;
+  after: SnapshotIndexConfig;
+}
+/** An index was removed from a type. */
+interface IndexRemovedChange extends DiffChangeBase {
+  kind: "index_removed";
+  indexName: string;
+  before: SnapshotIndexConfig;
+}
+/** An index configuration was modified. */
+interface IndexModifiedChange extends DiffChangeBase {
+  kind: "index_modified";
+  indexName: string;
+  before: SnapshotIndexConfig;
+  after: SnapshotIndexConfig;
+}
+/** A file field was added to a type. `before`/`after` hold the description. */
+interface FileAddedChange extends DiffChangeBase {
+  kind: "file_added";
+  fieldName: string;
+  after: string;
+}
+/** A file field was removed from a type. */
+interface FileRemovedChange extends DiffChangeBase {
+  kind: "file_removed";
+  fieldName: string;
+  before: string;
+}
+/** A file field description was modified. */
+interface FileModifiedChange extends DiffChangeBase {
+  kind: "file_modified";
+  fieldName: string;
+  before: string;
+  after: string;
+}
+/**
+ * A relationship was added to a type. `relationshipType` is optional for
+ * backward compatibility: diff.json files written by older SDK versions
+ * predate the field.
+ */
+interface RelationshipAddedChange extends DiffChangeBase {
+  kind: "relationship_added";
+  relationshipName: string;
+  relationshipType?: "forward" | "backward";
+  after: SnapshotRelationship;
+}
+/** A relationship was removed from a type. */
+interface RelationshipRemovedChange extends DiffChangeBase {
+  kind: "relationship_removed";
+  relationshipName: string;
+  relationshipType?: "forward" | "backward";
+  before: SnapshotRelationship;
+}
+/** A relationship configuration was modified. */
+interface RelationshipModifiedChange extends DiffChangeBase {
+  kind: "relationship_modified";
+  relationshipName: string;
+  relationshipType?: "forward" | "backward";
+  before: SnapshotRelationship;
+  after: SnapshotRelationship;
+}
+/**
+ * Type-level permissions were modified. `before`/`after` are optional for
+ * robustness against hand-edited or legacy diff.json files; consumers guard
+ * on their presence.
+ */
+interface PermissionModifiedChange extends DiffChangeBase {
+  kind: "permission_modified";
+  before?: SnapshotPermissionState;
+  after?: SnapshotPermissionState;
+}
+/** Type-level hook/validate script state for diff tracking. */
+interface TypeScriptsState {
+  typeHookExpr?: {
+    create?: string;
+    update?: string;
+  };
+  typeValidateExpr?: string;
+}
+/** Type-level hook/validate scripts changed. */
+interface TypeScriptsModifiedChange extends DiffChangeBase {
+  kind: "type_scripts_modified";
+  before: TypeScriptsState;
+  after: TypeScriptsState;
+}
+/**
+ * Single change in migration diff, discriminated by `kind` so that
+ * `before`/`after` are typed per change kind.
+ */
+type DiffChange = TypeAddedChange | TypeRemovedChange | TypeModifiedChange | TypeSettingsModifiedChange | FieldAddedChange | FieldRemovedChange | FieldModifiedChange | IndexAddedChange | IndexRemovedChange | IndexModifiedChange | FileAddedChange | FileRemovedChange | FileModifiedChange | RelationshipAddedChange | RelationshipRemovedChange | RelationshipModifiedChange | PermissionModifiedChange | TypeScriptsModifiedChange;
+/**
+ * Migration diff - changes between two schema versions
+ * Stored as XXXX/diff.json (e.g., 0001/diff.json)
+ */
+interface MigrationDiff {
+  /** Format version for future compatibility */
+  version: number;
+  namespace: string;
+  createdAt: string;
+  description?: string;
+  changes: DiffChange[];
+  /** Whether there are breaking changes (data loss or constraint violations possible) */
+  hasBreakingChanges: boolean;
+  /** List of breaking changes */
+  breakingChanges: BreakingChangeInfo[];
+  /** Whether there are non-breaking changes that may cause data loss (e.g. field/type removal) */
+  hasWarnings: boolean;
+  /** List of non-breaking warnings */
+  warnings: WarningChangeInfo[];
+  /** Whether a migration script is required to handle data migration */
+  requiresMigrationScript: boolean;
+  /** Explicit acknowledgment that this migration needs no script despite breaking changes */
+  scriptSkipped?: ScriptSkippedInfo;
+}
+/**
+ * Acknowledgment that a migration requiring a script intentionally has none.
+ * Recorded by `tailordb migration script <n> --no-script --reason "..."`.
+ */
+interface ScriptSkippedInfo {
+  reason: string;
+  acknowledgedAt: string;
+}
+/**
+ * Breaking change information in migration diff
+ */
+interface BreakingChangeInfo {
+  typeName: string;
+  fieldName?: string;
+  reason: string;
+  /** If true, this change is not supported and migration generation will fail */
+  unsupported?: boolean;
+  /** If true, show 3-step migration instructions for this unsupported change */
+  showThreeStepHint?: boolean;
+}
+/**
+ * Warning change information in migration diff.
+ *
+ * Warnings are non-breaking changes that may still cause data loss
+ * (e.g. removing a field or type). Unlike breaking changes, a migration
+ * script is not required, but writing one is recommended if you need to
+ * preserve or transform data before the change applies.
+ */
+interface WarningChangeInfo {
+  typeName: string;
+  fieldName?: string;
+  reason: string;
+}
+/**
+ * Check if a migration diff has any changes
+ * @param {MigrationDiff} diff - Migration diff to check
+ * @returns {boolean} True if diff has changes
+ */
+declare function hasChanges(diff: MigrationDiff): boolean;
+/**
+ * Format a migration diff for display
+ * @param {MigrationDiff} diff - Migration diff to format
+ * @returns {string} Formatted diff string
+ */
+declare function formatMigrationDiff(diff: MigrationDiff): string;
+/**
+ * Format a summary of the migration diff
+ * @param {MigrationDiff} diff - Migration diff to summarize
+ * @returns {string} Formatted summary string
+ */
+declare function formatDiffSummary(diff: MigrationDiff): string;
+//#endregion
+export { BreakingChangeInfo, DiffChange, FieldAddedChange, FieldModifiedChange, FieldRemovedChange, FileAddedChange, FileModifiedChange, FileRemovedChange, IndexAddedChange, IndexModifiedChange, IndexRemovedChange, MigrationDiff, PermissionModifiedChange, RelationshipAddedChange, RelationshipModifiedChange, RelationshipRemovedChange, ScriptSkippedInfo, SnapshotPermissionState, SnapshotTypeSettingsState, TypeAddedChange, TypeModifiedChange, TypeRemovedChange, TypeScriptsModifiedChange, TypeScriptsState, TypeSettingsModifiedChange, TypeSettingsPatch, WarningChangeInfo, formatDiffSummary, formatMigrationDiff, hasChanges };

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

@@ -0,0 +1,16 @@
+import { z } from "zod";
+//#region src/cli/commands/tailordb/migrate/generate.d.ts
+interface GenerateOptions {
+  configPath?: string;
+  name?: string;
+  yes?: boolean;
+  init?: boolean;
+}
+/**
+ * Generate migration files for TailorDB schema changes
+ * @param {GenerateOptions} options - Generation options
+ * @returns {Promise<void>} Promise that resolves when generation is complete
+ */
+declare function generate(options: GenerateOptions): Promise<void>;
+//#endregion
+export { GenerateOptions, generate };

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

@@ -0,0 +1,208 @@
+//#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;
+  default?: unknown;
+  /** 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;
+  };
+  typeHookExpr?: {
+    create?: string;
+    update?: string;
+  };
+  typeValidateExpr?: string;
+}
+/**
+ * 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 "../../../../tailor-proto/src/tailor/v1/tailordb_resource_pb.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,18 @@
+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,74 @@
+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 };