deepline 0.1.83 → 0.1.88

package/dist/index.d.mts

@@ -46,7 +46,7 @@ interface PlaySheetContractSnapshot {
     tableNamespace: string;
     columns: PlaySheetColumnContractSnapshot[];
 }
-type PlayStaticColumnProducerKindSnapshot = 'tool' | 'waterfall' | 'stepProgram' | 'playCall' | 'transform';
+type PlayStaticColumnProducerKindSnapshot = 'tool' | 'waterfall' | 'stepProgram' | 'playCall' | 'controlFlow' | 'transform';
 interface PlayStaticColumnProducerSnapshot {
     id: string;
     kind: PlayStaticColumnProducerKindSnapshot;
@@ -148,6 +148,15 @@ type PlayStaticSubstepSnapshot = PlayStaticSubstepMetadataSnapshot & ({
     sourceRange?: PlayStaticSourceRangeSnapshot;
     callDepth?: number;
     callPath?: string[];
+} | {
+    type: 'control_flow';
+    kind: 'conditional' | 'loop';
+    field: string;
+    steps: PlayStaticSubstepSnapshot[];
+    description?: string;
+    sourceRange?: PlayStaticSourceRangeSnapshot;
+    callDepth?: number;
+    callPath?: string[];
 } | {
     type: 'run_javascript';
     alias: string;
@@ -258,17 +267,33 @@ interface ResolvedConfig {
     /** Max retry count for transient failures. */
     maxRetries: number;
 }
+/** Column metadata returned by a customer data query. */
 interface CustomerDbColumn {
+    /** Column name as returned by the database. */
     name: string;
+    /** Internal table identifier when available. */
     table_id: number | null;
+    /** Internal data-type identifier when available. */
     data_type_id: number | null;
 }
+/**
+ * Result returned by {@link DeeplineClient.queryCustomerDb}.
+ *
+ * Rows are intentionally untyped because the schema depends on the caller's SQL
+ * query and selected customer tables.
+ */
 interface CustomerDbQueryResult {
+    /** Database command executed by the query endpoint. */
     command: string;
+    /** Total affected row count when reported by the database. */
     row_count: number | null;
+    /** Number of rows included in this response. */
     row_count_returned: number;
+    /** Whether server-side row limits truncated the result. */
     truncated: boolean;
+    /** Column metadata for the returned rows. */
     columns: CustomerDbColumn[];
+    /** Result rows. */
     rows: unknown[];
 }
 interface ToolPricingSummary {
@@ -288,6 +313,13 @@ interface ToolPricingSummary {
     details: string[];
 }
 
+/**
+ * Summary definition of a callable provider-backed tool.
+ *
+ * Returned by {@link DeeplineClient.listTools} and ranked tool search. Use
+ * `getTool(toolId)` or the matching HTTP describe route for provider-specific
+ * schema, examples, pricing, and extraction guidance before executing.
+ */
 interface ToolDefinition {
     /** Unique tool identifier used in API calls (e.g. `"apollo_people_search"`). */
     toolId: string;
@@ -385,28 +417,53 @@ interface ToolDefinition {
         term?: string;
     }>;
 }
+/**
+ * Query options for ranked tool/provider discovery.
+ */
 interface ToolSearchOptions {
+    /** Free-text search query. */
     query?: string;
+    /** Comma-separated category filter such as `company_search` or `email_finder`. */
     categories?: string;
+    /** Optional explicit search terms used by agent/CLI callers. */
     searchTerms?: string;
+    /** Search algorithm/version. Defaults to the current ranked mode. */
     searchMode?: 'v1' | 'v2';
+    /** Include backend debug metadata in the search response. */
     includeSearchDebug?: boolean;
 }
+/**
+ * Ranked tool/provider discovery response.
+ *
+ * Includes matching tools plus render/action hints used by the CLI and agents.
+ */
 interface ToolSearchResult {
+    /** Ranked matching tools. */
     tools: ToolDefinition[];
+    /** Count included in this response when available. */
     count?: number;
+    /** Total available count when the backend reports it. */
     total?: number;
+    /** Whether results were truncated by server-side limits. */
     truncated?: boolean;
+    /** Echoed query. */
     query?: string;
+    /** Parsed category filters. */
     categories?: string[];
+    /** Parsed search terms. */
     search_terms?: string[];
+    /** Search mode used. */
     search_mode?: 'v1' | 'v2';
+    /** Whether search fell back to category matching. */
     search_fallback_to_category?: boolean;
+    /** Hint explaining omitted play results when searching tools only. */
     omitted_plays_hint?: string;
+    /** Copyable CLI command templates for follow-up discovery/execution. */
     commandTemplates?: {
         describe?: string;
         execute?: string;
     };
+    /** Pre-rendered sections and actions for CLI/agent display. */
     render?: {
         sections?: Array<{
             title: string;
@@ -525,9 +582,19 @@ type PlayRunActionPackage = {
     datasetPath: string;
     format: 'csv';
 };
+/**
+ * Compact canonical package for an inspected play run.
+ *
+ * This object is designed for SDK/CLI/API consumers that need stable run
+ * metadata, output handles, and follow-up actions without reading dashboard
+ * internals.
+ */
 interface PlayRunPackage {
+    /** Package schema version. */
     schemaVersion: 1;
+    /** Package discriminator. */
     kind: 'play_run';
+    /** Run identity, status, timing, and dashboard metadata. */
     run: {
         id: string;
         playName: string;
@@ -539,8 +606,11 @@ interface PlayRunPackage {
         durationMs?: number | null;
         error?: string;
     };
+    /** Step-level summaries emitted by the runtime. */
     steps: Array<Record<string, unknown>>;
+    /** Named output summaries, including dataset handles and scalar outputs. */
     outputs: Record<string, Record<string, unknown>>;
+    /** Follow-up actions a caller can perform against the run. */
     next?: {
         inspect?: PlayRunActionPackage;
         export?: PlayRunActionPackage;
@@ -646,6 +716,10 @@ interface PlayRunListItem {
     closeTime: string | null;
     /** Duration string (e.g. `'2.5s'`). */
     executionTime: string | null;
+    /** Total Deepline credits charged for the run, when available. */
+    billingTotalCredits?: number;
+    /** Configured per-run Deepline credit cap, when available. */
+    billingMaxCreditsPerRun?: number | null;
     /** Metadata attached to the workflow. */
     memo: {
         /** Organization that owns this run. */
@@ -1123,6 +1197,13 @@ type EnrichCompiledConfig = {
 type ExecuteToolRawOptions = {
     includeToolMetadata?: boolean;
 };
+/**
+ * Standard provider/tool execution envelope returned by low-level SDK calls.
+ *
+ * `toolResponse.raw` contains the provider result. `extractedValues` and
+ * `extractedLists` contain Deepline-normalized getters when the tool exposes
+ * them. Billing fields are Deepline-facing and must not expose provider spend.
+ */
 type ToolExecution<TData = unknown, TMeta = Record<string, unknown>> = {
     status: string;
     job_id?: string;
@@ -1136,16 +1217,20 @@ type ToolExecution<TData = unknown, TMeta = Record<string, unknown>> = {
     billing?: Record<string, unknown>;
     [key: string]: unknown;
 };
+/** Filters for `client.runs.list(...)`. */
 type RunsListOptions = {
     play: string;
     status?: string;
 };
+/** Streaming options for `client.runs.tail(...)`. */
 type RunsTailOptions = {
     signal?: AbortSignal;
 };
+/** Log fetch options for `client.runs.logs(...)`. */
 type RunsLogsOptions = {
     limit?: number;
 };
+/** Persisted log response for one play run. */
 type RunsLogsResult = {
     runId: string;
     totalCount: number;
@@ -1156,12 +1241,14 @@ type RunsLogsResult = {
     hasMore: boolean;
     entries: string[];
 };
+/** One persisted runtime-sheet row returned by `client.runs.exportDatasetRows(...)`. */
 type PlaySheetRow = {
     key?: string;
     status?: string;
     data?: Record<string, unknown>;
     [key: string]: unknown;
 };
+/** Runtime-sheet rows and aggregate progress for one dataset/table namespace. */
 type PlaySheetRowsResult = {
     rows: PlaySheetRow[];
     summary?: {
@@ -1191,13 +1278,27 @@ type PlaySecretMetadata = {
     updatedAt: number;
     lastUsedAt?: number;
 };
+/**
+ * Public runs namespace exposed as `client.runs`.
+ *
+ * This namespace mirrors the canonical `/api/v2/runs` resource family and is
+ * the preferred low-level surface for polling, streaming, stopping, reading
+ * logs, and exporting durable dataset rows.
+ *
+ * @sdkReference client 020 client.runs
+ */
 type RunsNamespace = {
+    /** Get current run status by public run id. */
     get: (runId: string, options?: {
         full?: boolean;
     }) => Promise<PlayStatus>;
+    /** List runs for one play, optionally filtered by status. */
     list: (options: RunsListOptions) => Promise<PlayRunListItem[]>;
+    /** Stream run events and return the latest/terminal run status. */
     tail: (runId: string, options?: RunsTailOptions) => Promise<PlayStatus>;
+    /** Fetch persisted log lines for a run. */
     logs: (runId: string, options?: RunsLogsOptions) => Promise<RunsLogsResult>;
+    /** Export persisted rows for a runtime-sheet dataset/table namespace. */
     exportDatasetRows: (input: {
         playName: string;
         tableNamespace: string;
@@ -1205,6 +1306,7 @@ type RunsNamespace = {
         limit?: number;
         offset?: number;
     }) => Promise<PlaySheetRowsResult>;
+    /** Stop a running/waiting run. */
     stop: (runId: string, options?: {
         reason?: string;
     }) => Promise<StopPlayRunResult>;
@@ -1228,12 +1330,20 @@ type RunsNamespace = {
  *   baseUrl: 'http://localhost:3000',
  * });
  * ```
+ *
+ * @sdkReference client 010
  */
 declare class DeeplineClient {
     private readonly http;
     private readonly config;
+    /** Canonical run lifecycle namespace backed by `/api/v2/runs`. */
     readonly runs: RunsNamespace;
     /**
+     * Create a low-level SDK client.
+     *
+     * Most callers can omit options and let the SDK resolve auth/config from
+     * environment variables and CLI-managed credentials.
+     *
      * @param options - Optional overrides for API key, base URL, timeout, and retries.
      * @throws {@link ConfigError} if no API key can be resolved from any source.
      */
@@ -1247,7 +1357,14 @@ declare class DeeplineClient {
     private playCloneEditStarter;
     private summarizePlayListItem;
     private summarizePlayDetail;
+    /** List secret metadata visible to the current workspace. */
     listSecrets(): Promise<PlaySecretMetadata[]>;
+    /**
+     * Check whether a named secret exists, is active, and has a stored value.
+     *
+     * @param name - Secret name. It is normalized to uppercase before lookup.
+     * @returns Matching active secret metadata, or `null`.
+     */
     checkSecret(name: string): Promise<PlaySecretMetadata | null>;
     /**
      * List all available tools.
@@ -1303,7 +1420,19 @@ declare class DeeplineClient {
      * Deepline execution envelope.
      */
     executeTool<TData = unknown, TMeta = Record<string, unknown>>(toolId: string, input: Record<string, unknown>, options?: ExecuteToolRawOptions): Promise<ToolExecution<TData, TMeta>>;
+    /**
+     * Back-compatible alias for {@link executeTool}.
+     *
+     * Retained for callers that still use the older raw naming while the response
+     * envelope remains the same.
+     */
     executeToolRaw<TData = unknown, TMeta = Record<string, unknown>>(toolId: string, input: Record<string, unknown>, options?: ExecuteToolRawOptions): Promise<ToolExecution<TData, TMeta>>;
+    /**
+     * Run a bounded SQL query against the customer data plane.
+     *
+     * Use this from trusted backend or agent contexts only. The API enforces
+     * workspace scoping and row limits.
+     */
     queryCustomerDb(input: {
         sql: string;
         maxRows?: number;
@@ -1342,6 +1471,17 @@ declare class DeeplineClient {
      * ```
      */
     startPlayRun(request: StartPlayRunRequest): Promise<PlayRunStart>;
+    /**
+     * Start a play run and stream live runtime events from the same request.
+     *
+     * Use this when a caller wants low-level event handling instead of submitting
+     * first and then connecting to `streamPlayRunEvents(runId)`.
+     *
+     * @param request - Play run configuration.
+     * @param options - Optional streaming options.
+     * @param options.signal - Optional abort signal for the streaming request.
+     * @returns Async stream of play-scoped live events.
+     */
     startPlayRunStream(request: StartPlayRunRequest, options?: {
         signal?: AbortSignal;
     }): AsyncGenerator<PlayLiveEvent>;
@@ -1374,6 +1514,12 @@ declare class DeeplineClient {
         triggerMetadata?: unknown;
         triggerBindings?: unknown;
     }>;
+    /**
+     * Register multiple bundled play artifacts in one request.
+     *
+     * Used by packaging and prebuilt publication flows. Each artifact is compiled
+     * first when a compiler manifest is not already supplied.
+     */
     registerPlayArtifacts(artifacts: Array<{
         name: string;
         sourceCode: string;
@@ -1400,6 +1546,13 @@ declare class DeeplineClient {
             triggerBindings?: unknown;
         }>;
     }>;
+    /**
+     * Compile a bundled play artifact into the server-side compiler manifest.
+     *
+     * The manifest records imports, trigger bindings, static pipeline shape, and
+     * runtime metadata needed before a play artifact can be checked, registered,
+     * or run.
+     */
     compilePlayManifest(input: {
         name: string;
         sourceCode: string;
@@ -1420,12 +1573,24 @@ declare class DeeplineClient {
         sourceFiles?: Record<string, string>;
         artifact: Record<string, unknown>;
     }): Promise<PlayCheckResult>;
+    /**
+     * Compile legacy enrich command arguments into a runtime plan.
+     *
+     * This is primarily used by CLI compatibility paths that translate older
+     * enrichment commands onto the play runtime.
+     */
     compileEnrichPlan(input: {
         plan_args?: string[];
         config?: unknown;
     }): Promise<{
         config: EnrichCompiledConfig;
     }>;
+    /**
+     * Register an already-bundled play artifact and start a run from it.
+     *
+     * This is the low-level file-backed run path used by SDK/CLI packaging
+     * wrappers after local bundling has produced the runtime artifact.
+     */
     startPlayRunFromBundle(input: {
         name: string;
         sourceCode: string;
@@ -1502,6 +1667,12 @@ declare class DeeplineClient {
         contentType: string;
         bytes: number;
     }>): Promise<PlayStagedFileRef[]>;
+    /**
+     * Resolve staged play files by content hash without uploading bytes.
+     *
+     * Missing files are returned so callers can upload only the files the server
+     * does not already have.
+     */
     resolveStagedPlayFiles(files: Array<{
         logicalPath: string;
         contentHash: string;
@@ -1619,6 +1790,12 @@ declare class DeeplineClient {
      * ```
      */
     getRunLogs(runId: string, options?: RunsLogsOptions): Promise<RunsLogsResult>;
+    /**
+     * Export persisted runtime-sheet rows for a play dataset/table namespace.
+     *
+     * This is the SDK form of exporting `ctx.dataset(...).run()` output for a
+     * specific play and optional run id.
+     */
     getPlaySheetRows(input: {
         playName: string;
         tableNamespace: string;
@@ -1638,14 +1815,27 @@ declare class DeeplineClient {
     stopRun(runId: string, options?: {
         reason?: string;
     }): Promise<StopPlayRunResult>;
+    /**
+     * List callable plays visible to the workspace.
+     *
+     * Pass `origin: "prebuilt"` for Deepline-managed prebuilts or
+     * `origin: "owned"` for org-owned plays.
+     */
     listPlays(options?: {
         origin?: 'prebuilt' | 'owned';
         grep?: string;
         grepMode?: 'all' | 'any' | 'phrase';
     }): Promise<PlayListItem[]>;
+    /**
+     * Search callable plays and return compact play descriptions.
+     *
+     * Prebuilt plays are preferred by default because they have maintained
+     * contracts and stable run behavior.
+     */
     searchPlays(options: {
         query: string;
         compact?: boolean;
+        scope?: 'prebuilt' | 'owned' | 'all';
     }): Promise<PlayDescription[]>;
     /**
      * Get the full definition and state of a named play.
@@ -1665,6 +1855,12 @@ declare class DeeplineClient {
      * ```
      */
     getPlay(name: string): Promise<PlayDetail>;
+    /**
+     * Get a normalized play description suitable for agents and CLIs.
+     *
+     * The description includes runnable examples, input/output summaries, clone
+     * guidance, revision state, and latest run metadata when available.
+     */
     describePlay(name: string, options?: {
         compact?: boolean;
     }): Promise<PlayDescription>;
@@ -1991,6 +2187,8 @@ type PlayDatasetTransformOptions = {
  * small and bounded. `PlayDataset` intentionally does not expose `.rows`,
  * `.toArray()`, or other array aliases; those hide the runtime cost of loading
  * persisted rows into memory.
+ *
+ * @sdkReference runtime 190
  */
 interface PlayDataset<T> extends AsyncIterable<T> {
     readonly [PLAY_DATASET_BRAND]: true;
@@ -2036,6 +2234,35 @@ interface PlayDataset<T> extends AsyncIterable<T> {
 
 type EmailStatusVerdict = 'send' | 'send_with_caution' | 'verify_next' | 'hold' | 'drop';
 type EmailStatusValue = 'valid' | 'invalid' | 'catch_all' | 'valid_catch_all' | 'unknown' | 'do_not_mail' | 'spamtrap' | 'abuse' | 'disposable';
+type EmailDeliverability = 'high' | 'medium' | 'low' | 'unknown';
+type EmailMxClass = 'consumer_mailbox' | 'workspace_mailbox' | 'security_gateway' | 'on_prem' | 'unknown';
+type EmailStatus = {
+    verdict: EmailStatusVerdict;
+    status: EmailStatusValue;
+    verified: boolean;
+    confidence: number | null;
+    reasons: string[];
+    signals: {
+        catch_all: boolean | null;
+        deliverability: EmailDeliverability;
+        mx_class: EmailMxClass;
+        mx_provider: string | null;
+        mx_record: string | null;
+        fraud_score: number | null;
+        disposable: boolean | null;
+        role_based: boolean | null;
+        free_email: boolean | null;
+        abuse: boolean | null;
+        spamtrap: boolean | null;
+        suspect: boolean | null;
+        valid: boolean | null;
+    };
+    provider: {
+        name: string;
+        raw_status: string | boolean | number | null;
+        raw_score: number | null;
+    };
+};
 type EmailStatusMapEntry = {
     status: EmailStatusValue;
     verdict?: EmailStatusVerdict;
@@ -2065,6 +2292,153 @@ type EmailStatusExtractorConfig = {
     rules?: EmailStatusRule[];
 };
 
+declare const JOB_CHANGE_STATUS_VALUES: readonly ["moved", "no_change", "left_company", "unknown", "profile_unavailable", "no_new_company"];
+type JobChangeStatus = (typeof JOB_CHANGE_STATUS_VALUES)[number];
+type JobChangeGetterValue = {
+    status: JobChangeStatus;
+    date: string | null;
+    new_company: string | null;
+    new_title: string | null;
+};
+declare const PHONE_STATUS_VALUES: readonly ["valid", "invalid", "unknown"];
+type PhoneStatus = (typeof PHONE_STATUS_VALUES)[number];
+declare const DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS: {
+    readonly id: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly name: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly email: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly personal_email: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly phone: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly linkedin: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly linkedin_url: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly domain: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly website: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly first_name: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly last_name: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly full_name: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly company: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly company_name: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly organization_name: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly company_domain: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly company_website: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly company_linkedin_url: {
+        readonly identity: true;
+        readonly valueKind: "string";
+    };
+    readonly title: {
+        readonly identity: false;
+        readonly valueKind: "string";
+    };
+    readonly industry: {
+        readonly identity: false;
+        readonly valueKind: "string";
+    };
+    readonly status: {
+        readonly identity: false;
+        readonly valueKind: "string";
+    };
+    readonly job_change: {
+        readonly identity: false;
+        readonly valueKind: "job_change";
+    };
+    readonly job_change_status: {
+        readonly identity: false;
+        readonly valueKind: "job_change_status";
+        readonly enum: readonly ["moved", "no_change", "left_company", "unknown", "profile_unavailable", "no_new_company"];
+    };
+    readonly email_status: {
+        readonly identity: false;
+        readonly valueKind: "email_status";
+    };
+    readonly phone_status: {
+        readonly identity: false;
+        readonly valueKind: "phone_status";
+        readonly enum: readonly ["valid", "invalid", "unknown"];
+    };
+};
+type DeeplineExtractorTarget = keyof typeof DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS;
+declare const DEEPLINE_EXTRACTOR_TARGETS: DeeplineExtractorTarget[];
+type DeeplineEmailStatusGetterValue = EmailStatus | EmailStatusValue;
+type DeeplineGetterValueMap = {
+    id: string;
+    name: string;
+    email: string;
+    personal_email: string;
+    phone: string;
+    linkedin: string;
+    linkedin_url: string;
+    domain: string;
+    website: string;
+    first_name: string;
+    last_name: string;
+    full_name: string;
+    company: string;
+    company_name: string;
+    organization_name: string;
+    company_domain: string;
+    company_website: string;
+    company_linkedin_url: string;
+    title: string;
+    industry: string;
+    status: string;
+    job_change: JobChangeGetterValue;
+    job_change_status: JobChangeStatus;
+    email_status: DeeplineEmailStatusGetterValue;
+    phone_status: PhoneStatus;
+};
+type DeeplineGetterValue<TTarget extends DeeplineExtractorTarget = DeeplineExtractorTarget> = DeeplineGetterValueMap[TTarget];
+declare function isDeeplineExtractorTarget(value: string): value is DeeplineExtractorTarget;
+
 type ToolResultExecutionMetadata = {
     idempotent: true;
     cached: boolean;
@@ -2128,7 +2502,7 @@ type ToolExecuteResultBase<TResult = unknown, TMeta = Record<string, unknown>> =
         }>;
     };
 };
-type ToolExecuteResultAccessors<TExtracted extends Record<string, unknown> = Record<string, unknown>, TLists extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>> = {
+type ToolExecuteResultAccessors<TExtracted extends Record<string, unknown> = Partial<DeeplineGetterValueMap>, TLists extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>> = {
     extractedValues: {
         [K in keyof TExtracted]: ToolResultTargetAccessor<TExtracted[K]>;
     };
@@ -2148,8 +2522,30 @@ type ToolExecuteResultAccessors<TExtracted extends Record<string, unknown> = Rec
  * Use extractors first when a tool contract exposes them. Drop to
  * `toolResponse.raw` when you need provider-specific fields or when debugging
  * from persisted run rows.
+ *
+ * @sdkReference runtime 200
+ */
+type ToolExecuteResult<TResult = unknown, TMeta = Record<string, unknown>, TExtracted extends Record<string, unknown> = Partial<DeeplineGetterValueMap>, TLists extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>> = ToolExecuteResultBase<TResult, TMeta> & ToolExecuteResultAccessors<TExtracted, TLists>;
+
+/**
+ * Previous durable cell value passed to object-column resolvers.
+ *
+ * The runtime supplies this when a row+column is being recomputed after a
+ * previous value existed. `value` has the same type that the column returns;
+ * freshness metadata lives beside it.
+ *
+ * @sdkReference runtime 120
  */
-type ToolExecuteResult<TResult = unknown, TMeta = Record<string, unknown>, TExtracted extends Record<string, unknown> = Record<string, unknown>, TLists extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>> = ToolExecuteResultBase<TResult, TMeta> & ToolExecuteResultAccessors<TExtracted, TLists>;
+type PreviousCell<Value = unknown> = {
+    /** Previous completed value for this row+column. */
+    value: Value;
+    /** Millisecond timestamp when the previous value completed. */
+    completedAt?: number;
+    /** Millisecond timestamp when the previous value becomes stale; `null` means no expiry. */
+    staleAt?: number | null;
+    /** Resolved numeric TTL in seconds for the previous value, when present. */
+    staleAfterSeconds?: number;
+};
 
 /**
  * Optional trigger bindings for a play.
@@ -2177,6 +2573,8 @@ type ToolExecuteResult<TResult = unknown, TMeta = Record<string, unknown>, TExtr
  *   cron: { schedule: '0 2 * * *', timezone: 'UTC' },
  * });
  * ```
+ *
+ * @sdkReference runtime 030
  */
 type PlayBindings = {
     /** Optional per-run billing controls enforced by the runtime. */
@@ -2235,6 +2633,8 @@ type LoosePlayObject = {
  *
  * The `tool` value comes from live tool discovery. The `id` is the stable
  * logical call name inside this play and participates in replay/idempotency.
+ *
+ * @sdkReference runtime 160
  */
 type ToolExecutionRequest = {
     /** Stable logical id for this tool call within the play. */
@@ -2245,9 +2645,61 @@ type ToolExecutionRequest = {
     input: Record<string, unknown>;
     /** Human-readable description for logs and run inspection. */
     description?: string;
+    /** Numeric TTL in seconds for this tool checkpoint. */
     staleAfterSeconds?: number;
 };
-type StepResolver<Row, Value> = (row: Row, ctx: DeeplinePlayRuntimeContext, index: number) => Value | Promise<Value>;
+/**
+ * Freshness policy for dataset cells and step-program columns.
+ *
+ * Use a positive whole number of seconds for a fixed TTL. Use a function when
+ * the next expiry depends on the value that was just produced. The function
+ * receives the completed cell value; return a positive whole number of seconds
+ * to set the next expiry, or `null` to keep that value indefinitely.
+ *
+ * Result-based policies are evaluated only for dataset/step-program cells. The
+ * scalar `ctx.step`, `ctx.fetch`, `ctx.runPlay`, and `ctx.tools.execute` APIs
+ * accept numeric TTLs.
+ *
+ * @sdkReference runtime 080
+ */
+type StaleAfterSeconds<Value = unknown> = number | ((value: Value) => number | null);
+type StepResolver<Row, Value> = (row: Row, ctx: DeeplinePlayRuntimeContext, index: number, previousCell?: PreviousCell<Value>) => Value | Promise<Value>;
+/**
+ * Input object passed to an object-column `run` resolver.
+ *
+ * @sdkReference runtime 090
+ */
+type DatasetColumnRunInput<Row, Value> = {
+    /** Current row, including previously computed columns. */
+    row: Row;
+    /** Runtime context for tool/play/fetch/log calls. */
+    ctx: DeeplinePlayRuntimeContext;
+    /** Zero-based row index for this dataset run. */
+    index: number;
+    /**
+     * The prior stored value for this exact row+column when the runtime has
+     * decided the cell is due to run again. `previousCell.value` is the same type
+     * this column returns; metadata such as `completedAt` and `staleAt` lives
+     * beside it and is not mixed into the value.
+     */
+    previousCell?: PreviousCell<Value>;
+};
+/**
+ * Object-column form for `.withColumn(...)`.
+ *
+ * Use this when a column needs `runIf`, typed `previousCell`, or a
+ * result-based `staleAfterSeconds(value)` policy.
+ *
+ * @sdkReference runtime 100
+ */
+type DatasetColumnDefinition<Row, Value> = {
+    /** Compute one cell value. Receives the previous stored value when rerunning. */
+    run: (input: DatasetColumnRunInput<Row, Value>) => Value | Promise<Value>;
+    /** Optional row-level gate. Skipped rows produce `null` for this column. */
+    readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
+    /** Fixed or value-dependent freshness policy for this cell. */
+    readonly staleAfterSeconds?: StaleAfterSeconds<Value>;
+};
 type ConditionalStepResolver<Row, Value, Else = null> = {
     readonly kind: 'conditional';
     readonly when: (row: Row, index: number) => boolean | Promise<boolean>;
@@ -2255,9 +2707,16 @@ type ConditionalStepResolver<Row, Value, Else = null> = {
     readonly elseValue: Else;
     else<ValueElse>(value: ValueElse): ConditionalStepResolver<Row, Value, ValueElse>;
 };
-type StepOptions<Row> = {
+/**
+ * Options for row-level `.withColumn(...)` and `steps().step(...)` entries.
+ *
+ * @sdkReference runtime 110
+ */
+type StepOptions<Row, Value = unknown> = {
+    /** Optional row-level gate. Skipped rows produce `null` for this column. */
     readonly runIf?: (row: Row, index: number) => boolean | Promise<boolean>;
-    readonly staleAfterSeconds?: number;
+    /** Fixed or value-dependent freshness policy for this cell. */
+    readonly staleAfterSeconds?: StaleAfterSeconds<Value>;
 };
 type StepProgram<Input, Output, Return = Output> = {
     readonly kind: 'steps';
@@ -2265,7 +2724,7 @@ type StepProgram<Input, Output, Return = Output> = {
     readonly returnResolver?: StepResolver<Output, Return>;
     readonly __inputType?: (input: Input) => void;
     step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | ConditionalStepResolver<Output, Value> | StepProgramResolver<Output, Value>): StepProgram<Input, Output & Record<Name, Value>, Return>;
-    step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output>): StepProgram<Input, Output & Record<Name, Value | null>, Return>;
+    step<Name extends string, Value>(name: Name, resolver: StepResolver<Output, Value> | StepProgramResolver<Output, Value>, options: StepOptions<Output, Value>): StepProgram<Input, Output & Record<Name, Value | null>, Return>;
     return<Value>(resolver: StepResolver<Output, Value>): StepProgram<Input, Output, Value>;
 };
 type StepProgramResolver<Input, Return> = {
@@ -2276,11 +2735,16 @@ type StepProgramResolver<Input, Return> = {
 };
 type PlayStepProgramStep = {
     readonly name: string;
-    readonly staleAfterSeconds?: number;
+    readonly staleAfterSeconds?: StaleAfterSeconds;
     readonly resolver: StepResolver<Record<string, unknown>, unknown> | ConditionalStepResolver<Record<string, unknown>, unknown> | StepProgramResolver<Record<string, unknown>, unknown>;
 };
 type ColumnResolver<Row, Value> = StepResolver<Row, Value> | ConditionalStepResolver<Row, Value> | StepProgramResolver<Row, Value>;
 type StepProgramOutput<TProgram> = TProgram extends StepProgram<any, infer Output, any> ? Output : never;
+/**
+ * Builder returned by `ctx.dataset(...)` for row-level durable columns.
+ *
+ * @sdkReference runtime 070 .dataset(...).withColumn(name, resolver).run(options)
+ */
 type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
     /**
      * Define one output column for every row in this dataset.
@@ -2296,7 +2760,36 @@ type DatasetBuilder<InputRow extends object, OutputRow extends object> = {
      * @returns The same dataset builder with the new column type.
      */
     withColumn<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;
-    withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | StepProgramResolver<OutputRow, Value>, options: StepOptions<OutputRow>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
+    /**
+     * Define one output column with object-column authoring and a row gate.
+     *
+     * @param name - Output column name.
+     * @param definition - Object-column definition with required `runIf`.
+     * @returns The same dataset builder with a nullable column type for skipped rows.
+     */
+    withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value> & {
+        readonly runIf: (row: OutputRow, index: number) => boolean | Promise<boolean>;
+    }): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
+    /**
+     * Define one output column with object-column authoring.
+     *
+     * Use this form for typed `previousCell` access or result-based
+     * `staleAfterSeconds(value)` policies.
+     *
+     * @param name - Output column name.
+     * @param definition - Object-column definition.
+     * @returns The same dataset builder with the new column type.
+     */
+    withColumn<Name extends string, Value>(name: Name, definition: DatasetColumnDefinition<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value>>;
+    /**
+     * Define one output column with a resolver plus row-level options.
+     *
+     * @param name - Output column name.
+     * @param resolver - Computes the value for one row.
+     * @param options - Row gate and freshness options.
+     * @returns The same dataset builder with a nullable column type for skipped rows.
+     */
+    withColumn<Name extends string, Value>(name: Name, resolver: StepResolver<OutputRow, Value> | StepProgramResolver<OutputRow, Value>, options: StepOptions<OutputRow, Value>): DatasetBuilder<InputRow, OutputRow & Record<Name, Value | null>>;
     withColumns<Program extends StepProgram<OutputRow, object, unknown>>(program: Program): DatasetBuilder<InputRow, StepProgramOutput<Program>>;
     /** @deprecated Dataset `.step(...)` was replaced by `.withColumn(...)`. */
     step<Name extends string, Value>(name: Name, resolver: ColumnResolver<OutputRow, Value>): never;
@@ -2334,7 +2827,11 @@ type CsvInput<TRow extends object = Record<string, unknown>> = FileInput<{
     readonly row: TRow;
 }>;
 type ColumnMap<TRow extends object> = Partial<Record<Extract<keyof TRow, string>, string | readonly string[]>>;
-/** Options for loading a staged CSV with `ctx.csv(...)`. */
+/**
+ * Options for loading a staged CSV with `ctx.csv(...)`.
+ *
+ * @sdkReference runtime 050
+ */
 type CsvOptions = {
     /** Human-readable description for runtime logs and inspection. */
     description?: string;
@@ -2408,6 +2905,8 @@ interface DeeplinePlayRuntimeContext {
      * @param options - CSV load options.
      *
      * @returns A {@link PlayDataset} whose rows should usually flow directly into `ctx.dataset(...)`.
+     *
+     * @sdkReference runtime 040 ctx.csv(path, options)
      */
     csv<T = Record<string, unknown>>(path: string, options?: CsvOptions): Promise<PlayDataset<T>>;
     /**
@@ -2464,6 +2963,8 @@ interface DeeplinePlayRuntimeContext {
      *     row.company?.employeeCount > 100 ? 'enterprise' : 'smb')
      *   .run({ description: 'Enrich leads.' });
      * ```
+     *
+     * @sdkReference runtime 060 ctx.dataset(key, items)
      */
     dataset<TItem extends object>(key: string, items: PlayDatasetInput<TItem>): DatasetBuilder<TItem, TItem>;
     /**
@@ -2477,6 +2978,8 @@ interface DeeplinePlayRuntimeContext {
          *
          * @param request - Tool call request.
          * @returns Tool execution result.
+         *
+         * @sdkReference runtime 150 ctx.tools.execute(request)
          */
         execute<TOutput = LoosePlayObject>(request: ToolExecutionRequest & {
             staleAfterSeconds?: number;
@@ -2503,6 +3006,8 @@ interface DeeplinePlayRuntimeContext {
      * @param input - Program input.
      * @param options - Run options.
      * @returns Program output.
+     *
+     * @sdkReference runtime 180 ctx.runSteps(program, input, options)
      */
     runSteps<TInput extends Record<string, unknown>, TOutput>(program: StepProgram<TInput, any, TOutput>, input: TInput, options?: {
         description?: string;
@@ -2523,6 +3028,8 @@ interface DeeplinePlayRuntimeContext {
      * @param run - Computes the value once.
      * @param options - Checkpoint options.
      * @returns Checkpoint value.
+     *
+     * @sdkReference runtime 130 ctx.step(id, fn)
      */
     step<T>(id: string, run: () => T | Promise<T>, options?: {
         staleAfterSeconds?: number;
@@ -2539,6 +3046,8 @@ interface DeeplinePlayRuntimeContext {
      * @param url - URL to fetch.
      * @param init - Fetch options.
      * @returns Recorded response.
+     *
+     * @sdkReference runtime 170 ctx.fetch(key, url, init)
      */
     fetch(key: string, url: string | URL, init?: SecretAwareRequestInit, options?: {
         staleAfterSeconds?: number;
@@ -2551,6 +3060,11 @@ interface DeeplinePlayRuntimeContext {
         bodyText: string;
         json: unknown | null;
     }>;
+    secrets: {
+        get(name: string): SecretHandle;
+        bearer(secret: SecretHandle): SecretAuth;
+        header(header: string, secret: SecretHandle): SecretAuth;
+    };
     /**
      * Invoke another registered or file-backed play as a child workflow.
      *
@@ -2566,12 +3080,9 @@ interface DeeplinePlayRuntimeContext {
      * @param input - Input object passed to the child play.
      * @param options - Child play options.
      * @returns Child play output.
+     *
+     * @sdkReference runtime 140 ctx.runPlay(key, playRef, input, options)
      */
-    secrets: {
-        get(name: string): SecretHandle;
-        bearer(secret: SecretHandle): SecretAuth;
-        header(header: string, secret: SecretHandle): SecretAuth;
-    };
     runPlay<TOutput = unknown>(key: string, playRef: string | PlayReferenceLike, input: Record<string, unknown>, options: {
         description?: string;
         staleAfterSeconds?: number;
@@ -2626,6 +3137,8 @@ interface DeeplinePlayRuntimeContext {
  * // Cancel if needed
  * await job.cancel();
  * ```
+ *
+ * @sdkReference plays 030
  */
 interface PlayJob<TOutput = unknown> {
     /** Temporal workflow ID for this execution. */
@@ -2699,6 +3212,8 @@ interface PlayJob<TOutput = unknown> {
  * // Publish the current draft
  * await play.publish();
  * ```
+ *
+ * @sdkReference plays 020
  */
 interface DeeplineNamedPlay<TInput = Record<string, unknown>, TOutput = unknown> {
     /** The play's name. */
@@ -2740,6 +3255,39 @@ interface DeeplineNamedPlay<TInput = Record<string, unknown>, TOutput = unknown>
         revisionId?: string;
     }): Promise<TOutput>;
 }
+/**
+ * Tool/provider operations available from a connected {@link DeeplineContext}.
+ *
+ * This namespace is for regular SDK callers outside a play runtime. Inside a
+ * `definePlay(...)` body, use `ctx.tools.execute({ id, tool, input, ... })`
+ * so provider calls become durable runtime checkpoints.
+ *
+ * @sdkReference tools 010 DeeplineContext.tools
+ */
+type DeeplineToolsNamespace = {
+    /** List all available provider-backed tools. */
+    list(): Promise<ToolDefinition[]>;
+    /** Get detailed metadata for one provider-backed tool. */
+    get(toolId: string): Promise<ToolMetadata>;
+    /**
+     * Execute a provider-backed tool from a regular SDK process.
+     *
+     * For durable play code, prefer `ctx.tools.execute(...)` because the play
+     * runtime records the call under a stable id.
+     */
+    execute(toolId: string, input: Record<string, unknown>): Promise<ToolExecuteResult>;
+};
+/**
+ * Named-play discovery and handle operations from a connected {@link DeeplineContext}.
+ *
+ * @sdkReference plays 010 DeeplineContext.plays
+ */
+type DeeplinePlaysNamespace = {
+    /** List saved and callable plays visible to the current workspace. */
+    list(): Promise<PlayListItem[]>;
+    /** Return a typed handle for a named, saved, shared, or prebuilt play. */
+    get<TInput = Record<string, unknown>, TOutput = unknown>(name: string): DeeplineNamedPlay<TInput, TOutput>;
+};
 type PrebuiltPlayRef = {
     readonly playName: string;
     readonly name: string;
@@ -2763,6 +3311,8 @@ type PlayInputContract<TInput> = {
  * through `defineInput<T>(schema)`, or when configuration reads clearer as one
  * object. The shorthand `definePlay(name, fn, bindings?)` is equivalent for
  * simple file-backed plays.
+ *
+ * @sdkReference runtime 020
  */
 type DefinePlayConfig<TInput, TOutput extends PlayReturnObject> = {
     /** Play id/name. */
@@ -2842,9 +3392,19 @@ type PlayMetadata = {
  * const job = await deepline.play('email-waterfall').run({ domain: 'stripe.com' });
  * const output = await job.get();
  * ```
+ *
+ * @sdkReference entrypoints 020
  */
 declare class DeeplineContext {
     private readonly client;
+    /**
+     * Create a high-level SDK context.
+     *
+     * Most callers should use {@link Deepline.connect}; direct construction is
+     * equivalent when you already have explicit client options.
+     *
+     * @param options - Optional SDK client configuration.
+     */
     constructor(options?: DeeplineClientOptions);
     /**
      * Tool operations namespace.
@@ -2857,18 +3417,21 @@ declare class DeeplineContext {
      * const company = companyLookup.toolResponse.raw;
      * ```
      */
-    get tools(): {
-        /** List all available tools. */
-        list: () => Promise<ToolDefinition[]>;
-        /** Get detailed metadata for a tool. */
-        get: (toolId: string) => Promise<ToolMetadata>;
-        /** Execute a tool and return the standard execution envelope. */
-        execute: (toolId: string, input: Record<string, unknown>) => Promise<ToolExecuteResult>;
-    };
-    get plays(): {
-        list: () => Promise<PlayListItem[]>;
-        get: <TInput = Record<string, unknown>, TOutput = unknown>(name: string) => DeeplineNamedPlay<TInput, TOutput>;
-    };
+    get tools(): DeeplineToolsNamespace;
+    /**
+     * Play discovery and named-play handles.
+     *
+     * Use `plays.list()` for discovery and `plays.get(name)` when you prefer a
+     * namespace spelling over `ctx.play(name)`.
+     */
+    get plays(): DeeplinePlaysNamespace;
+    /**
+     * Convenience references for Deepline-managed prebuilt plays.
+     *
+     * Known prebuilts are exposed by camel-cased aliases. Any other property is
+     * converted into `prebuilt/<property>` so callers can pass the reference to
+     * `ctx.runPlay(...)`.
+     */
     get prebuilt(): Record<string, PrebuiltPlayRef>;
     /**
      * Get a named play handle for remote lifecycle operations.
@@ -2886,6 +3449,17 @@ declare class DeeplineContext {
      * ```
      */
     play<TInput = Record<string, unknown>, TOutput = unknown>(name: string): DeeplineNamedPlay<TInput, TOutput>;
+    /**
+     * Run a named or prebuilt play and wait for its output.
+     *
+     * This is the high-level SDK equivalent of `ctx.play(name).runSync(input)`.
+     * Inside a play runtime, prefer the in-play `ctx.runPlay(key, playRef, input,
+     * options)` form so the child run is checkpointed under a stable key.
+     *
+     * @param playOrRef - Play name or prebuilt/reference object.
+     * @param input - JSON input passed to the play.
+     * @returns Completed play output.
+     */
     runPlay<TInput = Record<string, unknown>, TOutput = unknown>(playOrRef: string | PlayReferenceLike, input: TInput): Promise<TOutput>;
 }
 /**
@@ -2899,6 +3473,8 @@ declare class DeeplineContext {
  * const tools = await deepline.tools.list();
  * const result = await deepline.tools.execute('test_company_search', { domain: 'stripe.com' });
  * ```
+ *
+ * @sdkReference entrypoints 010
  */
 declare class Deepline {
     /**
@@ -3189,4 +3765,4 @@ declare function writeCsvOutputFile(rows: Array<Record<string, unknown>>, stem:
  */
 declare function extractSummaryFields(payload: unknown): Record<string, Scalar>;
 
-export { AuthError, type ClearPlayHistoryRequest, type ClearPlayHistoryResult, type ColumnMap, type ColumnResolver, type ConditionalStepResolver, ConfigError, type CsvInput, DEEPLINE_TOOL_CATEGORIES, type DatasetBuilder, Deepline, DeeplineClient, type DeeplineClientOptions, DeeplineContext, DeeplineError, type DeeplineNamedPlay, type DeeplinePlayRuntimeContext, type DeeplineToolCategory, type DefinePlayConfig, type DefinedPlay, type FileInput, type LiveEventEnvelope, PLAY_BOOTSTRAP_COMPANY_FIELDS, PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_CONTACT_FIELDS, PLAY_BOOTSTRAP_FINDER_KINDS, PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER, PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER, PLAY_BOOTSTRAP_SOURCE_KINDS, PLAY_BOOTSTRAP_STAGE_KINDS, PLAY_BOOTSTRAP_TEMPLATES, PROD_URL, type PlayBindings, type PlayBootstrapEntityKind, type PlayBootstrapFinderKind, type PlayDataset, type PlayDatasetInput, type PlayInputContract, type PlayJob, type PlayListItem, type PlayLiveEvent, type PlayRevisionSummary, type PlayRunResult, type PlayRunStart, type PlayStatus, type PlayStepProgramStep, type PrebuiltPlayRef, type PublishPlayVersionRequest, type PublishPlayVersionResult, RateLimitError, type ResolvedConfig, SDK_API_CONTRACT, SDK_VERSION, type StartPlayRunRequest, type StepProgram, type StepProgramResolver, type StepResolver, type ToolDefinition, type ToolExecuteResult, type ToolExecution, type ToolMetadata, defineInput, definePlay, defineWorkflow, extractSummaryFields, formatPlayBootstrapFinderKinds, formatPlayBootstrapFinderKindsForSentence, formatPlayBootstrapTemplates, getDefinedPlayMetadata, isPlayBootstrapFinderKind, isPlayBootstrapTemplate, resolveConfig, runIf, steps, tryConvertToList, writeCsvOutputFile, writeJsonOutputFile };
+export { AuthError, type ClearPlayHistoryRequest, type ClearPlayHistoryResult, type ColumnMap, type ColumnResolver, type ConditionalStepResolver, ConfigError, type CsvInput, type CsvOptions, type CustomerDbQueryResult, DEEPLINE_EXTRACTOR_TARGETS, DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS, DEEPLINE_TOOL_CATEGORIES, type DatasetBuilder, type DatasetColumnDefinition, type DatasetColumnRunInput, Deepline, DeeplineClient, type DeeplineClientOptions, DeeplineContext, type DeeplineEmailStatusGetterValue, DeeplineError, type DeeplineExtractorTarget, type DeeplineGetterValue, type DeeplineGetterValueMap, type DeeplineNamedPlay, type DeeplinePlayRuntimeContext, type DeeplinePlaysNamespace, type DeeplineToolCategory, type DeeplineToolsNamespace, type DefinePlayConfig, type DefinedPlay, type FileInput, JOB_CHANGE_STATUS_VALUES, type JobChangeStatus, type LiveEventEnvelope, PHONE_STATUS_VALUES, PLAY_BOOTSTRAP_COMPANY_FIELDS, PLAY_BOOTSTRAP_COMPANY_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_CONTACT_FIELDS, PLAY_BOOTSTRAP_FINDER_KINDS, PLAY_BOOTSTRAP_OUTPUT_FIELD_BY_FINDER, PLAY_BOOTSTRAP_PEOPLE_PROVIDER_CATEGORY, PLAY_BOOTSTRAP_PROVIDER_CATEGORY_BY_FINDER, PLAY_BOOTSTRAP_SOURCE_KINDS, PLAY_BOOTSTRAP_STAGE_KINDS, PLAY_BOOTSTRAP_TEMPLATES, PROD_URL, type PhoneStatus, type PlayBindings, type PlayBootstrapEntityKind, type PlayBootstrapFinderKind, type PlayDataset, type PlayDatasetInput, type PlayInputContract, type PlayJob, type PlayListItem, type PlayLiveEvent, type PlayRevisionSummary, type PlayRunResult, type PlayRunStart, type PlaySheetRow, type PlaySheetRowsResult, type PlayStatus, type PlayStepProgramStep, type PrebuiltPlayRef, type PreviousCell, type PublishPlayVersionRequest, type PublishPlayVersionResult, RateLimitError, type ResolvedConfig, type RunsListOptions, type RunsLogsOptions, type RunsLogsResult, type RunsNamespace, type RunsTailOptions, SDK_API_CONTRACT, SDK_VERSION, type StaleAfterSeconds, type StartPlayRunRequest, type StepOptions, type StepProgram, type StepProgramResolver, type StepResolver, type StopPlayRunResult, type ToolDefinition, type ToolExecuteResult, type ToolExecution, type ToolExecutionRequest, type ToolMetadata, type ToolSearchOptions, type ToolSearchResult, defineInput, definePlay, defineWorkflow, extractSummaryFields, formatPlayBootstrapFinderKinds, formatPlayBootstrapFinderKindsForSentence, formatPlayBootstrapTemplates, getDefinedPlayMetadata, isDeeplineExtractorTarget, isPlayBootstrapFinderKind, isPlayBootstrapTemplate, resolveConfig, runIf, steps, tryConvertToList, writeCsvOutputFile, writeJsonOutputFile };