//#region src/environments.generated.d.ts

declare const ENVIRONMENTS: {
  readonly local: {
    readonly base_url: "http://localhost:4000";
    readonly description: "Development server";
  };
  readonly mock: {
    readonly base_url: "http://localhost:4010";
    readonly description: "Mock server with limited state — spin up using alvera-cli (https://github.com/alvera-ai/homebrew-tap)";
  };
  readonly demo: {
    readonly base_url: "https://demo.alvera.ai";
    readonly description: "Demo server";
  };
  readonly prod: {
    readonly base_url: "https://app.alvera.ai";
    readonly description: "Prod Server";
  };
};
declare const DEFAULT_ENVIRONMENT: "prod";
type EnvironmentName = keyof typeof ENVIRONMENTS;
//#endregion
//#region src/generated/types.gen.d.ts
/**
 * TextToSqlRequest
 *
 * Natural-language prompt to generate datalake SQL for, plus the data access mode.
 */
type TextToSqlRequest = {
  /**
   * Which lake to target: `raw`, `tokenized` or `redacted`
   */
  mode: 'raw' | 'tokenized' | 'redacted';
  /**
   * Natural-language description of the desired query
   */
  prompt: string;
};
/**
 * UserSearchResponse
 *
 * User SQL search resource. Created via `POST /datasets/:dataset/user-searches`
 * with a `WHERE`-clause body in `search_query`; the platform executes
 * `INSERT INTO search_results SELECT … WHERE <body>` to populate
 * `search_results` and reports back `status`, `results_count`, and
 * `error_message`.
 *
 * UserSearch carries no `data_access_mode` of its own — the capability check
 * runs where the lake's connection is acquired, via
 * `Platform.Datalakes.authorize_lake_access!/1`, which reads the ambient
 * session and raises 403 when the ceiling is insufficient. ExOpenApiUtils derives `UserSearchRequest` (writeable subset)
 * and `UserSearchResponse` (full readable shape) from this declaration via
 * the readOnly/writeOnly markers on each property.
 *
 */
type UserSearchResponse = {
  /**
   * SQL execution error message when status is `error`; null otherwise
   */
  readonly error_message?: string | null;
  /**
   * Generic-table identifier. Required when the dataset is a generic table; must be omitted otherwise.
   */
  generic_table_id?: string | null;
  /**
   * User search ID
   */
  readonly id?: string;
  /**
   * Resource type the search runs against (e.g. "patient", "appointment", "generic_table"). On `POST /datasets/:dataset/user-searches` this is taken from the URL path; on the response it echoes that value.
   */
  readonly resource_type?: string;
  /**
   * Number of rows the SQL search matched
   */
  readonly results_count?: number | null;
  /**
   * SQL `WHERE`-clause body. The platform wraps it in `INSERT INTO search_results SELECT … WHERE <body>`. Reference the table aliases exposed by the dataset's base decomposed query (see `GET /datasets/:dataset_type/metadata`).
   */
  search_query: string;
  /**
   * Search execution status
   */
  readonly status?: 'new' | 'in_progress' | 'completed' | 'error';
};
/**
 * ActionExecutionLogResponse
 *
 * Per-action execution log — child of a WorkflowExecutionLog, one row per scheduled action.
 */
type ActionExecutionLogResponse = {
  /**
   * Action ID
   */
  action_id: string;
  action_type: ActionType;
  /**
   * Batch identifier
   */
  batch_id?: string | null;
  /**
   * Completed-at timestamp
   */
  completed_at?: string | null;
  /**
   * Context key
   */
  context_key?: string | null;
  /**
   * Decision key (denormalised from action)
   */
  decision_key?: string | null;
  /**
   * Error description (no customer data)
   */
  error_message?: string | null;
  /**
   * External system reference (Twilio SID, SES message ID, etc.)
   */
  external_id?: string | null;
  /**
   * Action execution log ID
   */
  id: string;
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * How many times the job has been attempted. `0` means it has not run yet.
   */
  readonly job_attempt?: number | null;
  /**
   * When the job will next be attempted. Equal to `scheduled_at` until something moves it; a snoozing job carries the instant it wakes.
   */
  readonly job_next_attempt_at?: string | null;
  /**
   * State of the job carrying this action — one of `available`, `scheduled`, `executing`, `retryable`, `completed`, `discarded`, `cancelled`. Null when no job carries it.
   */
  readonly job_state?: string | null;
  /**
   * Rendered message body for this action (mode-driven; null when no message was sent)
   */
  readonly message_body?: string | null;
  /**
   * Cross-DB UUID of the message produced by this action (datalake-resident; no FK)
   */
  message_id?: string | null;
  /**
   * Execution mode (`live` = normal, `dry_run` = preview only)
   */
  mode: 'live' | 'dry_run';
  /**
   * Retry count
   */
  retry_count?: number;
  /**
   * Result of the action's runtime_filter Liquid expression
   */
  runtime_filter_result?: boolean | null;
  /**
   * Scheduled-at timestamp
   */
  scheduled_at?: string | null;
  /**
   * Started-at timestamp
   */
  started_at?: string | null;
  /**
   * Execution state
   */
  status: 'pending' | 'executing' | 'completed' | 'failed' | 'skipped' | 'filtered' | 'cancelled';
  /**
   * Last update timestamp
   */
  updated_at?: string;
  /**
   * Parent workflow execution log ID
   */
  workflow_execution_log_id: string;
  /**
   * Workflow ID
   */
  workflow_id: string;
};
/**
 * ManualUploadRequest
 *
 * Manual upload marker tool — no configuration fields, just an identity marker for manual ingestion workflows. Request
 */
type ManualUploadRequest = {
  [key: string]: unknown;
};
/**
 * ContextDatasetResponse
 *
 * Context dataset for a workflow — declares which records the context builder should load (and under what filter) before the enrichment and decision stages.
 */
type ContextDatasetResponse = {
  /**
   * Dataset type — either a standard industry resource (e.g. "patient", "appointment") or "generic_table" to reference a custom table
   */
  dataset_type: string;
  /**
   * Required when `dataset_type == "generic_table"`
   */
  generic_table_id?: string | null;
  /**
   * Context dataset ID
   */
  readonly id?: string;
  readonly inserted_at?: string;
  /**
   * Max records to load for this context dataset
   */
  limit?: number | null;
  /**
   * Ordering within the context-builder pipeline
   */
  position?: number;
  readonly updated_at?: string;
  /**
   * Liquid-templated SQL WHERE clause for filtering records at runtime. The context builder appends the legal entity FK automatically.
   */
  where_clause?: string | null;
  /**
   * Parent workflow id
   */
  readonly workflow_id?: string;
};
/**
 * DataActivationClientListResponse
 *
 * Paginated list of data activation clients
 */
type DataActivationClientListResponse = {
  /**
   * List of data activation clients
   */
  data: Array<DataActivationClientResponse>;
  meta: PaginationMeta;
};
/**
 * MembershipResponse
 *
 * Tenant membership — binds a user to a tenant with a role.
 */
type MembershipResponse = {
  /**
   * Membership ID
   */
  readonly id: string;
  /**
   * Tenant-membership role.
   */
  readonly role: 'member' | 'researcher' | 'admin';
  tenant?: TenantResponse;
};
/**
 * DatalakeCloudStorageCustomResponse
 */
type DatalakeCloudStorageCustomResponse = CloudStorageCustomResponse & {
  cloud_storage_type: 'custom';
};
/**
 * AgenticWorkflowResponse
 *
 * Agentic Workflow — event-driven automation pipeline
 */
type AgenticWorkflowResponse = {
  /**
   * Decision actions attached to this workflow (response — includes id, workflow_id and timestamps)
   */
  readonly actions?: Array<ActionResponse>;
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * Context-enrichment datasets loaded before the decision stage (response — includes id, workflow_id and timestamps)
   */
  readonly context_datasets?: Array<ContextDatasetResponse>;
  datalake?: DatalakeResponse;
  /**
   * Dataset type the workflow listens on (e.g. legal_entity, document, generic_table)
   */
  dataset_type: string;
  decision_config?: ComplexTemplateConfigResponse | null;
  /**
   * Workflow description
   */
  description: string;
  filter_config?: SimpleTemplateConfigResponse | null;
  /**
   * Generic table ID (required when dataset_type is generic_table)
   */
  generic_table_id?: string | null;
  /**
   * Workflow ID
   */
  id?: string;
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * Workflow name
   */
  name: string;
  /**
   * When true, skip MDM resolution
   */
  skip_mdm_resolution?: boolean;
  /**
   * URL-friendly slug
   */
  readonly slug?: string;
  /**
   * Workflow status. live = auto-fired by event sampling; draft = preview only (dry-run); manual = never auto-fired, but runs for real when an operator explicitly invokes it.
   */
  status: 'live' | 'draft' | 'manual';
  /**
   * Operator-authored labels. Free text — no taxonomy, no shared vocabulary. Not read by the execution pipeline, but they DO participate in the workflow checksum, so retagging shifts the drift fingerprint. REQUIRED on every write. Send `[]` for an untagged workflow — deliberately no default, so an omitted key is a 422 rather than a silent reset to empty.
   */
  tags: Array<string>;
  /**
   * Last update timestamp
   */
  updated_at?: string;
  /**
   * AI agents attached to this workflow (response — full detail with nested agent)
   */
  readonly workflow_ai_agents?: Array<WorkflowAiAgentResponse>;
};
/**
 * AdvancedMigrationRequest
 *
 * An advanced migration — SQL a person wrote by hand for one datalake, run by the same migrator that applies the platform's own generated changes. Once it has run it can no longer be edited or deleted. Request
 */
type AdvancedMigrationRequest = {
  /**
   * The SQL that reverses `up_statement`, used when rolling the datalake back.
   */
  down_statement: string;
  /**
   * Identifier for the migration, unique within the datalake. Must start with a capital letter and contain only letters, numbers and underscores — for example `RenameMemoToNote`.
   */
  name: string;
  /**
   * The SQL to run. Anything the platform will not generate for itself belongs here — renaming a column, changing its type, dropping one, adding an index.
   */
  up_statement: string;
};
/**
 * ManualToolInvocationResponse
 *
 * A manual test invocation of a tool. The request body carries only `tool_call` (polymorphic on `__type__`); all other fields are server-populated and returned in the response.
 */
type ManualToolInvocationResponse = {
  /**
   * Provider error message on failure.
   */
  readonly error_message?: string | null;
  /**
   * Invocation ID
   */
  readonly id?: string;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  /**
   * Provider response payload on success (provider-specific). SQL try-it returns `rows`, `row_count` and `truncated`; other providers return their own shape.
   */
  readonly result?: {
    /**
     * SQL try-it only — number of rows in `rows`.
     */
    row_count?: number;
    /**
     * SQL try-it only — result rows, each an array of column values.
     */
    rows?: Array<Array<unknown>>;
    /**
     * SQL try-it only — `true` when the preview filled its 100-row window, meaning this is a partial view and the query returns at least this many rows. Render it as a partial result, never as the complete answer.
     */
    truncated?: boolean;
    [key: string]: unknown;
  } | null;
  /**
   * Execution status — server-set. `pending` is the initial state, `success`/`error` reflect provider response.
   */
  readonly status?: 'pending' | 'success' | 'error';
  tool_call?: ({
    tool_call_type: 'sms_request';
  } & ManualToolInvocationSmsCallResponse) | ({
    tool_call_type: 'mms_request';
  } & ManualToolInvocationMmsCallResponse) | ({
    tool_call_type: 'email_request';
  } & ManualToolInvocationEmailCallResponse) | ({
    tool_call_type: 'restapi_request';
  } & ManualToolInvocationRestCallResponse) | ({
    tool_call_type: 'aws_lambda_request';
  } & ManualToolInvocationAwsLambdaCallResponse) | ({
    tool_call_type: 'sql_query';
  } & ManualToolInvocationSqlQueryCallResponse);
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
};
/**
 * CloudWatchLogGroupResponse
 *
 * AWS CloudWatch Logs authentication credential store. Referenced by ActionStatusUpdater for log-group polling.
 */
type CloudWatchLogGroupResponse = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * IAM role ARN to assume in the customer's AWS account (used when auth_method is assume_role)
   */
  assume_role_arn?: string | null;
  /**
   * External ID for the STS AssumeRole call, unique per customer
   */
  assume_role_external_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role' | 'assume_role';
  base_filter_pattern?: ComplexTemplateConfigResponse | null;
  /**
   * Custom CloudWatch Logs endpoint URL (e.g., http://localhost:4566 for MiniStack)
   */
  endpoint_url?: string | null;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
};
/**
 * S3CallRequest
 *
 * S3 file-path descriptor — identifies an object for downstream validation/read. Request
 */
type S3CallRequest = {
  /**
   * S3 object key/path (no s3:// prefix)
   */
  file_path: string;
};
/**
 * TenantResponse
 *
 * Tenant resource. The auto-generated `TenantRequest` shape carries only
 * the writable fields (`name`, `description`); `TenantResponse` returns the
 * full read surface (`id`, `slug`, `name`, `description`).
 *
 */
type TenantResponse = {
  /**
   * Optional free-text description; max 1000 chars.
   */
  description?: string | null;
  /**
   * Tenant ID
   */
  readonly id: string;
  /**
   * Human-readable tenant name. Required on create; max 160 chars.
   */
  name: string;
  /**
   * URL-friendly tenant slug — derived from `name` by the server.
   */
  readonly slug: string;
};
/**
 * ComplexTemplateConfigRequest
 *
 * Inline Liquid template configuration including the rendered-output JSON Schema Request
 */
type ComplexTemplateConfigRequest = {
  /**
   * Liquid template body (required for :custom type)
   */
  body?: string | null;
  /**
   * JSON Schema describing expected rendered output
   */
  output_schema: {
    [key: string]: unknown;
  } | null;
  /**
   * Filesystem path (required for :system type)
   */
  path?: string | null;
  /**
   * Template resolution type
   */
  type: 'system' | 'custom' | 'identity' | 'null';
};
/**
 * DataActivationClientLogResponse
 *
 * One log row per `(batch_id, dataset_table)`. A batch fans out into one log per dataset table — so a single run (one `batch_id`) produces multiple log rows, one per table the DAC writes into. Once `BatchMergeWorker` has finished, `output_files` carries one entry per bucket mode, each an `object_key` — a cloud-storage key, not a URL. To read an archive, presign the key with `POST /datalakes/{datalake_slug}/download-link`.
 */
type DataActivationClientLogResponse = {
  /**
   * Batch identifier stamped on every Oban job for this run
   */
  batch_id: string;
  /**
   * Owning Data Activation Client ID
   */
  readonly client_id: string;
  /**
   * Target dataset table for this slice (e.g. legal_entities, documents)
   */
  dataset_table: string;
  /**
   * Number of existing rows whose checksum changed (trigger-maintained)
   */
  dataset_updated?: number;
  /**
   * Structured failure reason when `status` is `failed` or `partial`; null otherwise.
   */
  readonly error?: string | null;
  /**
   * Run log ID
   */
  readonly id?: string;
  /**
   * Source file keys fetched for this slice
   */
  input_files?: Array<string>;
  readonly inserted_at?: string;
  /**
   * Merged NDJSON archives produced by `BatchMergeWorker`, one entry per bucket mode. Empty until the merge completes. Parse `object_key` (`s3://bucket/key`) and fetch a presigned URL via the datalake download-link endpoint.
   */
  readonly output_files?: Array<DacRawLogFileResponse>;
  /**
   * Total source rows ingested by this slice of the batch
   */
  rows_ingested?: number;
  /**
   * `processing` from the moment the slice is enqueued until the batch finishes — the column has no default, so this is written, not assumed. `succeeded` is written once by the batch callback, and only over `processing`. `failed` when the batch died before enqueueing any row — the fetch or the enqueue itself errored, and `rows_ingested` and `input_files` are 0/[] on such a row. `partial` when the batch ran and at least one row was refused on the way in; the rows that landed are still there. Read `error` for the reason in the last two.
   */
  status?: 'processing' | 'succeeded' | 'partial' | 'failed';
  readonly updated_at?: string;
};
/**
 * S3CallResponse
 *
 * S3 file-path descriptor — identifies an object for downstream validation/read.
 */
type S3CallResponse = {
  /**
   * S3 object key/path (no s3:// prefix)
   */
  file_path: string;
};
/**
 * MessageResponse
 *
 * A message the platform sent, as an authenticated link's calls return it
 */
type MessageResponse = {
  /**
   * The message as sent, links rewritten to the link prefix
   */
  readonly body?: string | null;
  /**
   * How the message was sent
   */
  readonly channel: 'sms' | 'mms' | 'email' | 'voice' | 'web_form' | 'push' | 'data_exchange';
  /**
   * When a person first clicked a link in the message, or Mailgun's click event
   */
  readonly clicked_at?: string | null;
  /**
   * When the provider reported delivery
   */
  readonly delivered_at?: string | null;
  /**
   * The provider's id for the message
   */
  readonly external_id?: string | null;
  /**
   * Why the provider failed the message
   */
  readonly failure_reason?: string | null;
  /**
   * When the link prefix host reported the form submitted
   */
  readonly form_submitted_at?: string | null;
  /**
   * The message's id in its raw lake
   */
  readonly id: string;
  /**
   * The recipient's `to` merged with what the action's metadata template rendered
   */
  readonly metadata?: {
    [key: string]: unknown;
  } | null;
  /**
   * When the link prefix host reported its landing page opened
   */
  readonly opened_at?: string | null;
  /**
   * When the provider queued the message
   */
  readonly queued_at?: string | null;
  /**
   * When the message was read; for email, Mailgun's opened event
   */
  readonly read_at?: string | null;
  /**
   * When the platform sent the message
   */
  readonly sent_at?: string | null;
  /**
   * The carrier the provider reported for an SMS
   */
  readonly sms_carrier?: string | null;
  /**
   * Delivery or engagement status; only ever moves forward
   */
  readonly status: 'pending' | 'accepted' | 'queued' | 'sending' | 'sent' | 'delivered' | 'read' | 'opened' | 'clicked' | 'form_submitted' | 'failed' | 'invalidated' | 'duplicate' | 'customer_rejected' | 'dry_run' | 'received';
  /**
   * The provider's or the host's detail for the status
   */
  readonly status_description?: string | null;
  /**
   * The email subject; empty for other channels
   */
  readonly subject?: string | null;
};
/**
 * ActionStatusUpdaterResponse
 *
 * Action Status Updater — automated polling for delivery status updates.
 */
type ActionStatusUpdaterResponse = {
  action_log_config: SimpleTemplateConfigResponse | null;
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * Cron schedule expression (e.g. "*30 * * * *")
   */
  cron_expression: string;
  /**
   * Datalake ID
   */
  datalake_id: string;
  /**
   * JSON Schema the rendered events_template output is validated against on every poll (required for restapi updaters). FLOOR: it must describe an array whose items are objects listing "external_id" in "required" — every event has to name the message it reconciles, so the events_template maps the provider's own id (messageId / id / sid) into external_id. Add whatever else your provider guarantees on top; the platform only enforces the floor.
   */
  events_output_schema?: {
    [key: string]: unknown;
  } | null;
  /**
   * Action Status Updater ID
   */
  readonly id?: string;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  /**
   * When the poll worker last completed a run (null until the first run)
   */
  readonly last_run_at?: string | null;
  /**
   * Why the last poll run failed; null when the run completed and read its whole window
   */
  readonly last_run_error?: string | null;
  /**
   * Events the last poll run fetched from the updater tool
   */
  readonly last_run_events_found?: number | null;
  /**
   * Outcome of the last poll run: `ok` when the run read its whole window, `error` when it stopped — read `last_run_error` for why. A run is never partial: every page of the window is read, one job per page.
   */
  readonly last_run_status?: 'ok' | 'error';
  /**
   * When a cron tick last skipped because an earlier run of this updater was still going (null if none has). A skip is not a run and leaves the last-run fields alone.
   */
  readonly last_skipped_at?: string | null;
  message_config: SimpleTemplateConfigResponse;
  /**
   * Updater name
   */
  name: string;
  /**
   * JSON Schema the rendered pagination_context_template output is validated against on every poll (required for restapi updaters). FLOOR: it must describe an object listing "has_next" in "required" — that key is what ends the page loop. Add the provider's cursor keys on top; the platform only enforces the floor.
   */
  pagination_context_output_schema?: {
    [key: string]: unknown;
  } | null;
  /**
   * IDs of sender tools whose messages this updater monitors
   */
  sender_tool_ids?: Array<string> | null;
  /**
   * Whether this updater may poll. The server sets cycle_detected when a run re-reads events it has already handled, and every later job then fails without calling the provider. Set it back to active to resume polling — nothing else clears it.
   */
  status?: 'active' | 'cycle_detected';
  /**
   * Tenant ID
   */
  readonly tenant_id?: string;
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
  updater_body: ({
    updater_body_type: 'cloud_watch_request';
  } & ActionStatusUpdaterCloudWatchQueryResponse) | ({
    updater_body_type: 'restapi_request';
  } & ActionStatusUpdaterRestCallResponse);
  /**
   * Tool providing auth credentials for polling
   */
  updater_tool_id: string;
  /**
   * Updater type — determines the updater_body shape
   */
  updater_type: 'cloud_watch' | 'restapi';
};
/**
 * IngestRequest
 *
 * Request body for data ingestion
 */
type IngestRequest = {
  /**
   * JSON data to ingest
   */
  data: {
    [key: string]: unknown;
  };
};
/**
 * WorkflowRunResponse
 *
 * A workflow invocation scheduled for a caller-chosen time. Every manual
 * invocation creates one, including an immediate send, which is simply
 * `scheduled_at` = now — there is no separate run-now path.
 *
 * A run is not a workflow run log. The run is the intent and is cancellable
 * while `scheduled`; the run log is the outcome it produces, and run logs also
 * arrive from Data Activation Client ingestion with no run behind them.
 *
 * The segment is resolved when the run **fires**, not when it is scheduled.
 * `matched_count` is the preview the operator saw; the audience is whatever
 * `execution_user_search_id` resolved to at send time, minus suppressed and
 * unreachable records.
 *
 */
type WorkflowRunResponse = {
  /**
   * Batch identifier for correlating with the workflow run log. Null until the run fires.
   */
  readonly batch_id?: string | null;
  /**
   * When the run reached a terminal state.
   */
  readonly completed_at?: string | null;
  /**
   * The search actually resolved when the run fired — its results are the audience that received the send. Null until the run fires; never the same row as `preview_user_search_id`.
   */
  readonly execution_user_search_id?: string | null;
  /**
   * Why the run could not fan out, when status is 'failed'.
   */
  readonly failure_reason?: string | null;
  /**
   * When the fan-out began. Null until the run fires.
   */
  readonly fired_at?: string | null;
  /**
   * Workflow run ID
   */
  readonly id?: string;
  /**
   * Bypasses dedupe and idempotency checks for every record this run matches.
   */
  manual_override?: boolean;
  /**
   * Audience size previewed at schedule time. NOT the number that received the send — the segment is resolved again when the run fires, and suppressed records are excluded then.
   */
  readonly matched_count?: number | null;
  /**
   * 'live' fires real tool calls; 'dry_run' runs the pipeline without making external calls.
   */
  mode?: 'live' | 'dry_run';
  /**
   * The resolved search this run was scheduled against. Create it with `POST /datasets/:dataset/user-searches`; its `results_count` becomes this run's `matched_count`.
   */
  preview_user_search_id: string;
  /**
   * When this run fires, in UTC. An immediate send is simply now. Each action still passes through the workflow's action window, so an action may execute later than this.
   */
  scheduled_at: string;
  /**
   * Run state. Cancellation is refused once processing.
   */
  readonly status?: 'scheduled' | 'processing' | 'completed' | 'cancelled' | 'failed';
  /**
   * The workflow this run invokes
   */
  readonly workflow_id?: string;
  /**
   * The run log this run produced. Null until the run fires.
   */
  readonly workflow_run_log_id?: string | null;
};
/**
 * ToolIntent
 *
 * Tool intent — what category of capability the tool provides.
 */
declare enum ToolIntent {
  SMS = "sms",
  MMS = "mms",
  EMAIL = "email",
  EXPORT = "export",
  VOICE = "voice",
  DATA_EXCHANGE = "data_exchange",
  STATUS_POLLER = "status_poller",
  LLM_ENRICHMENT = "llm_enrichment",
}
/**
 * AWSLambdaResponse
 *
 * AWS Lambda tool configuration for an external, user-provided Lambda ARN.
 */
type AwsLambdaResponse = {
  /**
   * AWS access key ID (required when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * Authentication method (required when type is external)
   */
  auth_method?: 'access_key' | 'iam_role' | 'cloudformation';
  base_payload?: ComplexTemplateConfigResponse | null;
  /**
   * User-provided environment variable key-value entries passed to the Lambda function
   */
  env_vars?: Array<unknown>;
  /**
   * Lambda function ARN
   */
  function_arn?: string | null;
  /**
   * User-provided secret key-value entries synced to AWS Secrets Manager
   */
  secrets?: Array<unknown>;
  /**
   * Lambda deployment type. `external` = user-provided Lambda ARN. This is the only supported type.
   */
  type: 'external';
};
/**
 * ActionSharePointExcelCallResponse
 */
type ActionSharePointExcelCallResponse = SharePointExcelCallResponse & {
  tool_call_type: 'microsoft_share_point_excel_request';
};
/**
 * DataActivationClientSQLQueryCallResponse
 */
type DataActivationClientSqlQueryCallResponse = SqlQueryCallResponse & {
  tool_call_type: 'sql_query';
};
/**
 * UserResponse
 *
 * Lean user reference — id, email, and names
 */
type UserResponse = {
  /**
   * User email
   */
  email: string;
  /**
   * First name
   */
  first_name?: string | null;
  /**
   * User ID
   */
  readonly id: string;
  /**
   * Last name
   */
  last_name?: string | null;
};
/**
 * ExecuteActionRequest
 *
 * Request body for executing a workflow action for a dataset record
 */
type ExecuteActionRequest = {
  /**
   * ID of the dataset record to process
   */
  dataset_id: string;
  /**
   * Decision key identifying which action to execute (e.g. 'send_welcome_email')
   */
  decision_key: string;
  /**
   * When true, bypasses idempotency and dedupe checks — action will fire even if already executed for this dataset record. Filters still apply. Mirrors `/run-workflow`'s `manual_override` field.
   */
  manual_override?: boolean;
  /**
   * Execution mode. 'live' fires real tool calls; 'dry_run' runs the full pipeline and records the computed payload without making external calls.
   */
  mode?: 'live' | 'dry_run';
  /**
   * When true, the action's `trigger_template` schedule is bypassed and the queued job is dispatched immediately. The ActionExecutionLog still records the trigger-rendered `scheduled_at` — only the Oban job is fast-forwarded. Use this to force an action whose trigger renders a future instant (e.g. a year-roll birthday SMS) to fire now, which is the only way to drive such a workflow to completion inside a live test or cookbook run. An action whose trigger renders a past instant does not need it: a past `scheduled_at` is staged on the next pass and runs on its own.
   */
  trigger_override?: boolean;
};
/**
 * InteroperabilityRunResponse
 *
 * Pipeline output for a single row. `stage` indicates the last pipeline stage reached; `transformed`/`mdm_input` are populated only when that stage executed successfully.
 */
type InteroperabilityRunResponse = {
  /**
   * Result of the row-level Liquid filter.
   */
  filter_result: 'pass' | 'skip';
  /**
   * Output of `mdm_input_config` rendering. `null` when filtered or when mdm_input_config is null/identity.
   */
  mdm_input?: {
    [key: string]: unknown;
  } | null;
  /**
   * `completed` = row passed filter, transform, and mdm_input. `filtered` = skipped by filter_template (transform/mdm_input not run).
   */
  stage: 'completed' | 'filtered';
  /**
   * Output of `template_config` rendering. `null` when stage == "filtered".
   */
  transformed?: {
    [key: string]: unknown;
  } | null;
};
/**
 * ErrorResponse
 *
 * Error response
 */
type ErrorResponse = {
  /**
   * Error details - values can be strings or arrays of strings (for validation errors)
   */
  errors?: {
    [key: string]: string | Array<string>;
  };
};
/**
 * ChecksumResponse
 *
 * Server-computed drift fingerprint for a submitted config.
 */
type ChecksumResponse = {
  /**
   * sha256 fingerprint over the config's authored fields, hex-lowercased
   */
  checksum: string;
};
/**
 * ActionType
 *
 * Workflow action category — selects the downstream dispatcher.
 */
declare enum ActionType {
  SMS = "sms",
  MMS = "mms",
  EMAIL = "email",
  VOICE = "voice",
  DATA_EXCHANGE = "data_exchange",
  DATA_ACTIVATION = "data_activation",
}
/**
 * MDMVerifyRequest
 *
 * Request body for MDM identity verification.
 *
 * Every legal entity is ultimately a **person** or a **company**, so the identity
 * fields are organized along that ontology rather than per industry. All identity
 * fields are optional on the wire, and every datalake reads the same set.
 *
 * At least one field that can stand alone as evidence is required: `first_name`,
 * `last_name`, `preferred_name`, `date_of_birth`, `business_name`, `date_formed`,
 * `phone`, `identifiers` or `addresses`. The rest (`legal_entity_type`,
 * `middle_name`, `citizenship_country`, `nationality`, `doing_business_as_names`,
 * `jurisdiction_country`, `email`) are accepted but cannot be the only evidence.
 * A body with none returns 422 in the house error envelope, pointer `/base`.
 *
 * Every property below is cast by `Platform.MDMInput.verification_changeset/2`:
 * `@verification_fields` plus the `identifiers` and `addresses` embeds. Keep the
 * two in step — a property advertised here but absent there is accepted by the
 * router and then silently dropped by `cast/3`, which reads to the caller as "my
 * attribute did not match".
 *
 */
type MdmVerifyRequest = {
  /**
   * Addresses to match against the legal entity's own — every domain. Each supplied component must agree (case- and whitespace-insensitive); components left out are not compared, and at least one address in the list must match.
   */
  addresses?: Array<{
    /**
     * City / locality
     */
    city?: string;
    /**
     * Country
     */
    country?: string;
    /**
     * Postal code
     */
    postal_code?: string;
    /**
     * State / region
     */
    state?: string;
    /**
     * Street line 1
     */
    street1?: string;
    /**
     * Street line 2
     */
    street2?: string;
  }>;
  /**
   * Business name (fuzzy match incl. doing-business-as names)
   */
  business_name?: string;
  /**
   * Citizenship country
   */
  citizenship_country?: string;
  /**
   * Company formation date (component-fuzzy match)
   */
  date_formed?: string;
  /**
   * Date of birth (component-fuzzy match)
   */
  date_of_birth?: string;
  /**
   * Doing-business-as names
   */
  doing_business_as_names?: Array<string>;
  /**
   * Email address
   */
  email?: string;
  /**
   * Given/first name (fuzzy match over first/middle/preferred)
   */
  first_name?: string;
  /**
   * Identifiers for exact (system, value) matching — every domain
   */
  identifiers?: Array<{
    /**
     * Issuing country
     */
    country?: string;
    /**
     * Identifier kind (e.g. us_ssn, lei, digital_identifier)
     */
    id_type?: string;
    /**
     * Identifier system (e.g. lei_register, us_ssn_authority)
     */
    system: string;
    /**
     * Identifier value
     */
    value: string;
  }>;
  /**
   * Jurisdiction country
   */
  jurisdiction_country?: string;
  /**
   * Family/last name (fuzzy match)
   */
  last_name?: string;
  /**
   * The legal entity id to verify against
   */
  legal_entity_id: string;
  /**
   * individual | business | household
   */
  legal_entity_type?: string;
  /**
   * Middle name
   */
  middle_name?: string;
  /**
   * Nationality
   */
  nationality?: string;
  /**
   * Phone number
   */
  phone?: string;
  /**
   * Preferred/nickname
   */
  preferred_name?: string;
};
/**
 * ActionResponse
 *
 * Workflow action — executes when the decision table routes to this `decision_key`. Polymorphic `tool_call` payload is variant-specific via `tool_call_type` discriminator.
 */
type ActionResponse = {
  action_type: ActionType;
  /**
   * Hour (0–23) when the action's execution window closes
   */
  action_window_end?: number | null;
  /**
   * Hour (0–23) when the action's execution window opens (failsafe, typically SMS)
   */
  action_window_start?: number | null;
  /**
   * Unique decision_key within the workflow — maps to a decision-table outcome
   */
  decision_key: string;
  /**
   * Action ID
   */
  readonly id?: string;
  /**
   * Liquid template producing the idempotency key; receives checksum, legal_entity_id, legal_entity_id, workflow_id, action_id, decision_key
   */
  idempotency_template: string;
  readonly inserted_at?: string;
  /**
   * Liquid template rendered to JSON once per send, on every action type. Stored on the message the send writes, and returned by the authenticated-link exchange as metadata (optional). A template that does not render fails the send.
   */
  metadata_template?: string | null;
  /**
   * Display order within the workflow
   */
  position?: number;
  /**
   * Liquid template evaluated at execution time; when falsy, the action is skipped
   */
  runtime_filter?: string | null;
  tool_call: ({
    tool_call_type: 'sms_request';
  } & ActionSmsCallResponse) | ({
    tool_call_type: 'mms_request';
  } & ActionMmsCallResponse) | ({
    tool_call_type: 'email_request';
  } & ActionEmailCallResponse) | ({
    tool_call_type: 'sql_query';
  } & ActionSqlQueryCallResponse) | ({
    tool_call_type: 'restapi_request';
  } & ActionRestCallResponse) | ({
    tool_call_type: 'sftp_request';
  } & ActionSftpCallResponse) | ({
    tool_call_type: 'microsoft_share_point_excel_request';
  } & ActionSharePointExcelCallResponse) | ({
    tool_call_type: 'aws_lambda_request';
  } & ActionAwsLambdaCallResponse) | ({
    tool_call_type: 'manual_upload';
  } & ActionManualUploadCallResponse) | ({
    tool_call_type: 'run_data_activation_client';
  } & ActionRunDataActivationClientCallResponse);
  /**
   * Tool that executes this action. Required for every action type except data_activation, which refuses one: its client carries its own tool.
   */
  tool_id?: string | null;
  /**
   * Liquid template that determines when this action executes
   */
  trigger_template: string;
  readonly updated_at?: string;
  /**
   * Parent workflow id
   */
  readonly workflow_id?: string;
};
/**
 * ManualUploadCallRequest
 *
 * Identity manual-upload marker. No fields — the discriminator alone indicates the tool call is a manual upload. Request
 */
type ManualUploadCallRequest = {
  [key: string]: unknown;
};
/**
 * InteroperabilityContractResponse
 *
 * Declarative execution spec binding a `(datalake, resource_type)` pair to the ingestion pipeline: filter → transform → mdm_input → resolve → upsert.
 */
type InteroperabilityContractResponse = {
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * Owning datalake ID (matches `:datalake_slug` path segment). Server-set on create; request bodies should omit this — it is taken from the path.
   */
  readonly datalake_id?: string;
  /**
   * Optional description
   */
  description?: string | null;
  /**
   * Liquid filter body. Renders to empty/whitespace → row passes; any non-empty trimmed render → row is skipped (rendered string is the skip reason). Nil/empty body = no filter.
   */
  filter_template?: string | null;
  /**
   * Generic table ID (required when resource_type == "generic_table")
   */
  generic_table_id?: string | null;
  /**
   * Contract ID
   */
  id?: string;
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * AI agents attached to this contract (response — full detail with nested agent)
   */
  readonly interoperability_contract_ai_agents?: Array<InteroperabilityContractAiAgentResponse>;
  mdm_input_config?: SimpleTemplateConfigResponse | null;
  /**
   * Human-readable contract name
   */
  name: string;
  /**
   * Dataset this contract targets (e.g. "legal_entity", "beneficial_owner", "generic_table")
   */
  resource_type: string;
  /**
   * URL-friendly slug (derived from name on insert; immutable)
   */
  slug?: string;
  /**
   * Whether this contract was auto-created by the system (read-only, cannot be edited or deleted)
   */
  readonly system_created?: boolean;
  template_config: SimpleTemplateConfigResponse;
  /**
   * Template type (synced from template_config.type)
   */
  type?: 'system' | 'custom' | 'identity' | 'null';
  /**
   * Last update timestamp
   */
  updated_at?: string;
};
/**
 * ActionSMSCallResponse
 */
type ActionSmsCallResponse = SmsCallResponse & {
  tool_call_type: 'sms_request';
};
/**
 * ToolAWSLambdaResponse
 */
type ToolAwsLambdaResponse = AwsLambdaResponse & {
  tool_body_type: 'aws_lambda';
};
/**
 * ToolManualUploadResponse
 */
type ToolManualUploadResponse = ManualUploadResponse & {
  tool_body_type: 'manual_upload';
};
/**
 * ExecuteSqlMeta
 *
 * Structural and pagination metadata for an `execute-sql` result — enough for an agent to
 * reason about the shape of the result without scanning the rows. The pagination fields
 * (`page`, `page_size`, `total_count`, `total_pages`) mirror `PaginationMeta`; their values
 * come from the Lotus window result, not Flop.
 *
 */
type ExecuteSqlMeta = {
  /**
   * Result column names, in order
   */
  columns: Array<string>;
  /**
   * SQL command tag (e.g. `SELECT`)
   */
  command?: string | null;
  /**
   * Query execution time in milliseconds
   */
  duration_ms?: number | null;
  /**
   * Rows returned in this page
   */
  num_rows: number;
  /**
   * 1-based page number
   */
  page: number;
  /**
   * Rows per page actually applied (after capping)
   */
  page_size: number;
  /**
   * Total rows across all pages (null if uncounted)
   */
  total_count: number | null;
  /**
   * Total pages (null if uncounted)
   */
  total_pages: number | null;
};
/**
 * InvitationResponse
 *
 * Pending tenant invitation — resolved into a Membership on accept.
 */
type InvitationResponse = {
  /**
   * Recipient email address. Must be unique per tenant.
   */
  email: string;
  /**
   * Invitation ID
   */
  readonly id?: string;
  /**
   * Tenant-membership role to grant on acceptance. NOT the platform-wide `User.role` enum — `tenant_admin` here is a tenant-scoped admin, not a platform admin.
   */
  role: 'member' | 'researcher' | 'admin';
  tenant?: TenantResponse;
};
/**
 * ToolRequest
 *
 * Tool — a configurable capability reference for external services. Request
 */
type ToolRequest = {
  /**
   * Data Source ID
   */
  data_source_id?: string | null;
  /**
   * Datalake ID
   */
  datalake_id?: string;
  /**
   * Tool description
   */
  description?: string | null;
  intent?: ToolIntent;
  /**
   * Tool name
   */
  name?: string;
  response_extractor?: ComplexTemplateConfigRequest;
  /**
   * Tool status
   */
  status?: 'draft' | 'active' | 'inactive' | 'error' | 'marked_for_deletion';
};
/**
 * SimpleTemplateConfigRequest
 *
 * Inline Liquid template configuration (output_schema is server-derived, never request-supplied) Request
 */
type SimpleTemplateConfigRequest = {
  /**
   * Liquid template body (required for :custom type)
   */
  body?: string | null;
  /**
   * Filesystem path (required for :system type)
   */
  path?: string | null;
  /**
   * Template resolution type
   */
  type: 'system' | 'custom' | 'identity' | 'null';
};
/**
 * DownloadUrlResponse
 *
 * Presigned download URL for a stored cloud-storage artifact.
 */
type DownloadUrlResponse = {
  /**
   * Presigned URL valid for a short TTL; fetch the artifact within the window.
   */
  url: string;
};
/**
 * SMSCallResponse
 *
 * SMS tool-call config — Liquid-templated recipient and body, transactional/promotional category, and the prefix its links go out on.
 */
type SmsCallResponse = {
  body: SimpleTemplateConfigResponse;
  /**
   * Address of the host that serves this action's links. Every URL in the body goes out as <link_prefix>/<token>. An absolute http or https URL, path allowed, with no query, fragment or trailing slash.
   */
  link_prefix: string;
  /**
   * How many days each link resolves after the send
   */
  link_validity_days?: number;
  /**
   * SMS category — transactional vs promotional
   */
  sms_type?: 'transactional' | 'promotional';
  to: SimpleTemplateConfigResponse;
};
/**
 * AWSLambdaCallResponse
 *
 * AWS Lambda invocation descriptor — Liquid-templated payload + timeout.
 */
type AwsLambdaCallResponse = {
  payload: SimpleTemplateConfigResponse;
  /**
   * Lambda invocation timeout in milliseconds (max 900000 = 15 minutes)
   */
  timeout_ms?: number;
};
/**
 * RESTCallResponse
 *
 * REST API call descriptor — HTTP method, path, body, params, pagination context template, and events extraction template. Reused across ActionStatusUpdater polling, data activation clients, tool protocols, OAuth token fetching, and chat completion; events_template is the status-poll extraction concern and is required only there.
 */
type RestCallResponse = {
  body?: SimpleTemplateConfigResponse | null;
  events_template?: SimpleTemplateConfigResponse | null;
  /**
   * HTTP method
   */
  method: 'head' | 'get' | 'put' | 'post' | 'delete' | 'patch';
  pagination_context_template: SimpleTemplateConfigResponse;
  params?: SimpleTemplateConfigResponse | null;
  path: SimpleTemplateConfigResponse;
};
/**
 * CloudStorageCustomResponse
 *
 * Custom S3-compatible cloud storage configuration — for MinIO, DigitalOcean Spaces, Backblaze B2, and other S3-compatible services. Requires a custom endpoint URL.
 */
type CloudStorageCustomResponse = {
  /**
   * Access key ID
   */
  access_key_id: string;
  /**
   * Base path prefix for objects within the bucket
   */
  base_path?: string;
  /**
   * Bucket name
   */
  bucket: string;
  /**
   * Custom S3-compatible endpoint URL (required)
   */
  endpoint: string;
  /**
   * Storage region (e.g., us-east-1)
   */
  region: string;
};
/**
 * UploadLinkRequest
 *
 * Request body for creating a presigned upload link for bulk ingest
 */
type UploadLinkRequest = {
  /**
   * MIME type of the file to be uploaded. Must match one of the supported container formats.
   */
  content_type: 'application/x-ndjson' | 'text/csv' | 'application/pdf' | 'image/png' | 'image/jpeg' | 'image/webp';
  /**
   * Original filename. Used to derive the stored object's extension (.ndjson or .csv).
   */
  filename: string;
};
/**
 * DataActivationClientManualUploadCallRequest
 */
type DataActivationClientManualUploadCallRequest = ManualUploadCallRequest & {
  tool_call_type: 'manual_upload';
};
/**
 * SharePointResponse
 *
 * Microsoft SharePoint integration via the Microsoft Graph API. Supports sites, document libraries, and lists with client-credential or managed-identity auth.
 */
type SharePointResponse = {
  /**
   * Microsoft Graph authentication method
   */
  auth_method: 'client_credentials' | 'managed_identity';
  /**
   * Microsoft tenant ID (GUID)
   */
  azure_tenant_id: string;
  base_path?: ComplexTemplateConfigResponse | null;
  /**
   * Azure AD application/client ID (used when auth_method is client_credentials)
   */
  client_id?: string | null;
  /**
   * Optional specific drive ID to access
   */
  drive_id?: string | null;
  /**
   * Optional path within the drive (e.g., Documents/Reports)
   */
  drive_path?: string | null;
  /**
   * Type of SharePoint resource to interact with
   */
  resource_type: 'site' | 'library' | 'list';
  /**
   * SharePoint site URL (e.g., https://contoso.sharepoint.com/sites/finance)
   */
  site_url?: string | null;
};
/**
 * SimpleTemplateConfigResponse
 *
 * Inline Liquid template configuration (output_schema is server-derived, never request-supplied)
 */
type SimpleTemplateConfigResponse = {
  /**
   * Liquid template body (required for :custom type)
   */
  body?: string | null;
  /**
   * Filesystem path (required for :system type)
   */
  path?: string | null;
  /**
   * Template resolution type
   */
  type: 'system' | 'custom' | 'identity' | 'null';
};
/**
 * RESTAPIResponse
 *
 * REST API tool configuration with OpenAPI-compliant authentication (API key, basic, bearer, OAuth2, OIDC) plus base Liquid templates.
 */
type RestapiResponse = {
  /**
   * Where to send the API key (header or query parameter)
   */
  api_key_location?: 'header' | 'query';
  /**
   * Header or query-parameter name for the API key
   */
  api_key_name?: string | null;
  /**
   * Authentication method
   */
  auth_method: 'none' | 'api_key' | 'basic' | 'bearer' | 'oauth2' | 'oidc';
  base_body?: SimpleTemplateConfigResponse | null;
  base_headers?: SimpleTemplateConfigResponse | null;
  base_path?: SimpleTemplateConfigResponse | null;
  base_query?: SimpleTemplateConfigResponse | null;
  /**
   * Base URL (https) of the REST API endpoint
   */
  base_url: string;
  /**
   * OAuth2 client ID
   */
  oauth2_client_id?: string | null;
  /**
   * OAuth2 grant type
   */
  oauth2_grant_type?: 'client_credentials' | 'authorization_code';
  /**
   * OAuth2 scope(s)
   */
  oauth2_scope?: string | null;
  /**
   * OAuth2 token cache TTL in seconds
   */
  oauth2_token_ttl?: number | null;
  /**
   * OAuth2 token endpoint URL
   */
  oauth2_token_url?: string | null;
  /**
   * OIDC client ID
   */
  oidc_client_id?: string | null;
  /**
   * OIDC issuer URL for discovery
   */
  oidc_issuer_url?: string | null;
  /**
   * OIDC token cache TTL in seconds
   */
  oidc_token_ttl?: number | null;
  /**
   * Request content type
   */
  request_type: 'json' | 'xml' | 'form_urlencoded' | 'multipart_form';
  /**
   * Response content type
   */
  response_type: 'json' | 'xml' | 'text' | 'binary';
  /**
   * Request timeout in milliseconds (max 300000)
   */
  timeout_ms: number;
  /**
   * Username (used when auth_method is basic)
   */
  username?: string | null;
};
/**
 * DataActivationClientRESTCallResponse
 */
type DataActivationClientRestCallResponse = RestCallResponse & {
  tool_call_type: 'restapi_request';
};
/**
 * SystemTemplateListResponse
 *
 * List of system templates available to this datalake.
 */
type SystemTemplateListResponse = {
  /**
   * Sorted list of system template configs.
   */
  data: Array<SystemTemplateConfig>;
};
/**
 * DataActivationClientS3CallResponse
 */
type DataActivationClientS3CallResponse = S3CallResponse & {
  tool_call_type: 's3_request';
};
/**
 * RunDataActivationClientCallRequest
 *
 * Runs a data activation client for the row that started the workflow, with the tool call the template renders for that row in place of the client's stored one. Request
 */
type RunDataActivationClientCallRequest = {
  /**
   * Slug of the data activation client to run, in the workflow's datalake
   */
  client_slug: string;
  /**
   * Liquid template rendered against the row that started the workflow, to the client's whole tool call as JSON — the shape the run-manually endpoint takes. It replaces the client's stored tool call for this run only.
   */
  tool_call_override_template: string;
};
/**
 * EmailCallResponse
 *
 * Email tool-call config — Liquid-templated recipient, subject, and body, and the prefix its links go out on.
 */
type EmailCallResponse = {
  body: SimpleTemplateConfigResponse;
  /**
   * Address of the host that serves this action's links. Every href in the body goes out as <link_prefix>/<token>. An absolute http or https URL, path allowed, with no query, fragment or trailing slash.
   */
  link_prefix: string;
  /**
   * How many days each link resolves after the send
   */
  link_validity_days?: number;
  subject: SimpleTemplateConfigResponse;
  to: SimpleTemplateConfigResponse;
};
/**
 * ActionSQLQueryCallResponse
 */
type ActionSqlQueryCallResponse = SqlQueryCallResponse & {
  tool_call_type: 'sql_query';
};
/**
 * SFTPCallResponse
 *
 * SFTP file descriptor — remote path + expected MIME content type.
 */
type SftpCallResponse = {
  /**
   * Expected MIME content type (e.g. application/json)
   */
  content_type: string;
  /**
   * Remote file path on the SFTP server
   */
  path: string;
};
/**
 * ActionStatusUpdaterRefreshRequest
 *
 * Optional polymorphic updater_body override for this refresh. When omitted or empty, the updater's persisted updater_body is used.
 */
type ActionStatusUpdaterRefreshRequest = {
  /**
   * One-shot polymorphic updater_body override — e.g. a widened start_time/end_time window for a historical backfill. Same `updater_body_type` discriminator and variants as ActionStatusUpdaterRequest.updater_body. The persisted updater is not modified.
   */
  updater_body?: ({
    updater_body_type: 'ActionStatusUpdaterRESTCallRequest';
  } & ActionStatusUpdaterRestCallRequest) | ({
    updater_body_type: 'ActionStatusUpdaterCloudWatchQueryRequest';
  } & ActionStatusUpdaterCloudWatchQueryRequest) | null;
};
/**
 * ToolTwilioRequest
 */
type ToolTwilioRequest = TwilioRequest & {
  tool_body_type: 'twilio';
};
/**
 * WorkflowAiAgentResponse
 *
 * Join entry linking an AI agent to a workflow at a specific execution position in the enrichment pipeline.
 */
type WorkflowAiAgentResponse = {
  ai_agent?: MinimalAiAgentResponse;
  /**
   * AI agent ID
   */
  ai_agent_id: string;
  context_mapping_config: SimpleTemplateConfigResponse;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  /**
   * Execution order in the enrichment pipeline
   */
  position: number;
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
};
/**
 * WorkflowLogListResponse
 *
 * Paginated list of workflow execution logs
 */
type WorkflowLogListResponse = {
  /**
   * List of workflow execution logs
   */
  data: Array<WorkflowLogResponse>;
  meta: PaginationMeta;
};
/**
 * SystemDatasetListResponse
 *
 * The dataset name strings the platform registers. Identical for every datalake.
 */
type SystemDatasetListResponse = {
  /**
   * Sorted unique dataset name strings (e.g. `legal_entity`, `document`, `action_log`).
   */
  datasets: Array<string>;
};
/**
 * GenericTableListResponse
 *
 * Paginated list of generic tables
 */
type GenericTableListResponse = {
  /**
   * List of generic tables
   */
  data: Array<GenericTableResponse>;
  meta: PaginationMeta;
};
/**
 * MMSCallResponse
 *
 * MMS tool-call config — Liquid-templated recipient, optional caption, plain public media URL, and the prefix its links go out on.
 */
type MmsCallResponse = {
  body?: SimpleTemplateConfigResponse;
  /**
   * Address of the host that serves this action's links. Every URL in the body goes out as <link_prefix>/<token>. An absolute http or https URL, path allowed, with no query, fragment or trailing slash.
   */
  link_prefix: string;
  /**
   * How many days each link resolves after the send
   */
  link_validity_days?: number;
  /**
   * Public http(s) URL of the media to attach — re-staged into the tool's S3 media bucket (End User Messaging) or fetched by Twilio directly
   */
  media_url: string;
  to: SimpleTemplateConfigResponse;
};
/**
 * ManualToolInvocationEmailCallResponse
 */
type ManualToolInvocationEmailCallResponse = EmailCallResponse & {
  tool_call_type: 'email_request';
};
/**
 * ToolSharePointResponse
 */
type ToolSharePointResponse = SharePointResponse & {
  tool_body_type: 'sharepoint';
};
/**
 * SharePointExcelCallRequest
 *
 * Microsoft SharePoint request descriptor — drive URL + Excel sheet + search params. Request
 */
type SharePointExcelCallRequest = {
  /**
   * Microsoft Azure tenant identifier (UUID)
   */
  azure_tenant_id: string;
  /**
   * SharePoint drive URL
   */
  drive_url: string;
  /**
   * Search parameters applied when locating files
   */
  search_params: string;
  /**
   * Excel sheet number (0-indexed) within the workbook
   */
  sheet_number: number;
};
/**
 * DACRawLogFileResponse
 *
 * A single merged NDJSON archive produced by BatchMergeWorker, tagged by bucket mode.
 */
type DacRawLogFileResponse = {
  /**
   * Bucket the archive lives in. One archive is written per log, and it is raw.
   */
  mode: 'raw';
  /**
   * Cloud-storage object key of the merged NDJSON archive
   */
  object_key: string;
};
/**
 * DataActivationClientManualUploadCallResponse
 */
type DataActivationClientManualUploadCallResponse = ManualUploadCallResponse & {
  tool_call_type: 'manual_upload';
};
/**
 * DerivedLakeTablesResponse
 *
 * Every table a derived lake's copy carries, and how far each one has got.
 *
 * Every table, not only the ones behind — a caller cannot ask to re-copy a
 * table it cannot see, and a table someone merely suspects has to be listed
 * even when the copy says it is fine.
 *
 */
type DerivedLakeTablesResponse = {
  /**
   * One entry per table the copy carries, ordered by name
   */
  data: Array<{
    /**
     * Whether this table has finished arriving
     */
    caught_up: boolean;
    /**
     * The same state in words, identical to what the platform's own screen shows
     */
    label: string;
    /**
     * Every table `POST .../resync` would empty for this one: the table
     * itself, plus anything that points at it, transitively. Postgres will
     * not empty a table anything references, so re-copying a parent means
     * re-copying its children too. Present so a caller can say how many
     * before offering the action; only computed for tables that are behind,
     * and `null` for the rest.
     *
     */
    resync_empties?: Array<string> | null;
    /**
     * How far this table has got. Only `caught_up` has arrived —
     * `finished_copy` means the first pass is done and the changes since
     * have not been applied yet, so a table sitting there is still behind.
     *
     */
    state: 'waiting_to_start' | 'copying' | 'finished_copy' | 'catching_up' | 'caught_up';
    /**
     * Table name
     */
    table: string;
  }>;
};
/**
 * ManualToolInvocationSMSCallResponse
 */
type ManualToolInvocationSmsCallResponse = SmsCallResponse & {
  tool_call_type: 'sms_request';
};
/**
 * ActionStatusUpdaterCloudWatchQueryResponse
 */
type ActionStatusUpdaterCloudWatchQueryResponse = CloudWatchQueryResponse & {
  updater_body_type: 'cloud_watch_request';
};
/**
 * ActionMMSCallResponse
 */
type ActionMmsCallResponse = MmsCallResponse & {
  tool_call_type: 'mms_request';
};
/**
 * ToolSQLDatabaseResponse
 */
type ToolSqlDatabaseResponse = SqlDatabaseResponse & {
  tool_body_type: 'sql_database';
};
/**
 * SystemTemplateConfig
 *
 * One system template — identifier, Liquid source, and optional output schema.
 */
type SystemTemplateConfig = {
  /**
   * Raw Liquid template source.
   */
  content: string;
  /**
   * JSON Schema describing the template's rendered output, read from the companion `_*.meta.json`. `null` when no schema is declared.
   */
  output_schema: {
    [key: string]: unknown;
  } | null;
  /**
   * System template identifier — the same string the UI stores when a user selects a system template (e.g. `ai_agents/contact_message_categorizer`).
   */
  path: string;
};
/**
 * BatchLogResponse
 *
 * Batch-level workflow run log — aggregation of per-event execution logs
 */
type BatchLogResponse = {
  /**
   * Batch identifier (manual:{user_search_id} or DAC batch_id)
   */
  batch_id: string;
  completed_at?: string | null;
  /**
   * Successfully completed WELs
   */
  completed_wels?: number;
  /**
   * Datalake ID
   */
  datalake_id?: string;
  /**
   * Number of events expected to produce WELs
   */
  expected_events?: number;
  /**
   * Failed WELs
   */
  failed_wels?: number;
  /**
   * Workflow run log ID
   */
  id?: string;
  inserted_at?: string;
  last_refreshed_at?: string | null;
  started_at?: string | null;
  /**
   * Batch status
   */
  status: 'pending' | 'completed' | 'partial' | 'failed';
  /**
   * Tenant ID
   */
  tenant_id?: string;
  /**
   * Total WELs found at last refresh
   */
  total_wels?: number;
  /**
   * Parent workflow ID
   */
  workflow_id?: string;
};
/**
 * AiAgentInvokeRequest
 *
 * Request body for invoking an AI agent with input variables and optional file attachments.
 */
type AiAgentInvokeRequest = {
  /**
   * Optional file references for multimodal processing. Each entry is a storage key returned by the upload-link endpoint paired with the MIME type used during upload.
   */
  files?: Array<{
    /**
     * MIME type of the uploaded file.
     */
    content_type: 'application/pdf' | 'image/png' | 'image/jpeg' | 'image/webp';
    /**
     * Cloud storage key returned by POST /tenants/:tenant_slug/datalakes/:datalake_slug/upload-link.
     */
    key: string;
  }>;
  /**
   * Input variables passed to the agent's prompt template. Must conform to the agent's input_schema if one is defined.
   */
  input: {
    [key: string]: unknown;
  };
};
/**
 * DataActivationClientBatchResponse
 *
 * One record per run. A run fans out into one `DataActivationClientLog` per dataset table it writes into; this is the run itself. To wait on a run, read `closed_at` here rather than reconstructing it from those logs — it is set exactly once, however the run ended.
 */
type DataActivationClientBatchResponse = {
  /**
   * Run identifier, stamped on every Oban job and every per-table log row of this run
   */
  batch_id: string;
  /**
   * Owning Data Activation Client ID
   */
  readonly client_id: string;
  /**
   * When the run was attempted and exhausted. Null while it is still going. It does not mean rows landed and it does not mean the archive was merged — read `status` for the outcome, and only once this is set.
   */
  readonly closed_at?: string | null;
  /**
   * Run record ID
   */
  readonly id?: string;
  /**
   * When the run started
   */
  readonly inserted_at?: string;
  /**
   * Source rows enqueued for this run. The run's own count; each per-table log keeps its own.
   */
  rows_total?: number;
  /**
   * How the run ended. **It means nothing until `closed_at` is set** — a run still in flight always reads `processing`. `failed` when the run died before writing anything; `partial` when it ran and at least one row was refused on the way in; `skipped` when it ran and there was nothing to do, because the file was empty, every row was filtered out, or the client has no contracts.
   */
  status?: 'processing' | 'succeeded' | 'partial' | 'skipped' | 'failed';
  readonly updated_at?: string;
};
/**
 * AdvancedMigrationResponse
 *
 * An advanced migration — SQL a person wrote by hand for one datalake, run by the same migrator that applies the platform's own generated changes. Once it has run it can no longer be edited or deleted.
 */
type AdvancedMigrationResponse = {
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * The datalake this migration belongs to. Taken from the URL, not the body.
   */
  readonly datalake_id?: string;
  /**
   * The SQL that reverses `up_statement`, used when rolling the datalake back.
   */
  down_statement: string;
  /**
   * Advanced migration ID
   */
  readonly id?: string;
  /**
   * Created at
   */
  readonly inserted_at?: string;
  /**
   * Identifier for the migration, unique within the datalake. Must start with a capital letter and contain only letters, numbers and underscores — for example `RenameMemoToNote`.
   */
  name: string;
  /**
   * The SQL to run. Anything the platform will not generate for itself belongs here — renaming a column, changing its type, dropping one, adding an index.
   */
  up_statement: string;
  /**
   * Updated at
   */
  readonly updated_at?: string;
  /**
   * Execution order, assigned by the platform from a sequence. Migrations run lowest-first.
   */
  readonly version?: number;
};
/**
 * ManualUploadCallResponse
 *
 * Identity manual-upload marker. No fields — the discriminator alone indicates the tool call is a manual upload.
 */
type ManualUploadCallResponse = {
  [key: string]: unknown;
};
/**
 * ActionStatusUpdaterRESTCallResponse
 */
type ActionStatusUpdaterRestCallResponse = RestCallResponse & {
  updater_body_type: 'restapi_request';
};
/**
 * WorkflowRunListResponse
 *
 * Paginated list of workflow runs
 */
type WorkflowRunListResponse = {
  /**
   * List of workflow runs
   */
  data: Array<WorkflowRunResponse>;
  meta: PaginationMeta;
};
/**
 * MinimalAiAgentResponse
 *
 * AI Agent — identifier and runtime fields only (no tenant/datalake nesting)
 */
type MinimalAiAgentResponse = {
  /**
   * Which lake the agent reads. `tokenized` means the agent's context is read from the tokenized copy, so it never sees a real identifier. It is enforced, not advisory: an agent set to `tokenized` in an environment with no tokenized lake fails its enrichment step rather than falling back to raw.
   */
  data_access: 'raw' | 'tokenized';
  /**
   * Agent description
   */
  description?: string | null;
  /**
   * Whether the agent is enabled
   */
  enabled: boolean;
  /**
   * AI Agent ID
   */
  id?: string;
  /**
   * JSON Schema describing the agent's input contract — validated by the runner against caller context on every invocation.
   */
  input_schema: {
    [key: string]: unknown;
  };
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * JSON Schema for LLM response format
   */
  llm_response_schema: {
    [key: string]: unknown;
  } | null;
  /**
   * Maximum tokens for LLM response
   */
  max_tokens: number;
  /**
   * LLM model identifier
   */
  model: string;
  /**
   * Agent name
   */
  name: string;
  prompt_config: SimpleTemplateConfigResponse;
  /**
   * URL-friendly slug
   */
  slug?: string;
  /**
   * Sampling temperature (0.0–2.0)
   */
  temperature: number;
  tool?: ToolResponse;
  /**
   * Tool ID
   */
  tool_id: string;
  /**
   * Last update timestamp
   */
  updated_at?: string;
};
/**
 * GenericTableColumnResponse
 *
 * Generic table column definition.
 */
type GenericTableColumnResponse = {
  /**
   * Column description
   */
  description: string;
  is_array?: boolean;
  is_checksum?: boolean;
  is_required?: boolean;
  is_unique?: boolean;
  /**
   * Column name
   */
  name: string;
  privacy_requirement?: 'none' | 'redact' | 'tokenize';
  /**
   * What the column holds, as opposed to how it is stored. Nullable.
   */
  semantic_kind?: 'string' | 'text' | 'email' | 'phone' | 'date' | 'json' | 'image' | 'pdf' | 'attachment';
  /**
   * Display title
   */
  title: string;
  /**
   * Column data type
   */
  type: 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'datetime' | 'time' | 'decimal' | 'jsonb' | 'uuid';
};
/**
 * DatasetSearchResponse
 *
 * Double-paginated dataset search results scoped to a `UserSearch`. The
 * `meta` object carries two `Flop.Meta`-shaped sub-objects:
 *
 * - `sql` — outer page over `search_results` (up to 1000 dataset IDs per
 * chunk; cap dictated by Postgres' `WHERE id IN (^ids)` plan). `null`
 * when the request was not bound to a `user_search_id`.
 * - `flop` — inner Flop page over the resource (default 20 rows).
 *
 */
type DatasetSearchResponse = {
  /**
   * Array of dataset records
   */
  data: Array<{
    [key: string]: unknown;
  }>;
  /**
   * Two-tier pagination metadata
   */
  meta: {
    flop: PaginationMeta;
    /**
     * Outer page over search_results — null when no UserSearch bound
     */
    sql?: PaginationMeta | unknown;
  };
  user_search: UserSearchResponse;
};
/**
 * InvitationRequest
 *
 * Pending tenant invitation — resolved into a Membership on accept. Request
 */
type InvitationRequest = {
  /**
   * Recipient email address. Must be unique per tenant.
   */
  email: string;
  /**
   * Tenant-membership role to grant on acceptance. NOT the platform-wide `User.role` enum — `tenant_admin` here is a tenant-scoped admin, not a platform admin.
   */
  role: 'member' | 'researcher' | 'admin';
};
/**
 * ActionAWSLambdaCallResponse
 */
type ActionAwsLambdaCallResponse = AwsLambdaCallResponse & {
  tool_call_type: 'aws_lambda_request';
};
/**
 * EndUserMessagingResponse
 *
 * AWS End User Messaging tool configuration for sending MMS via the SendMediaMessage API.
 */
type EndUserMessagingResponse = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * IAM role ARN to assume in the customer's AWS account (used when auth_method is assume_role)
   */
  assume_role_arn?: string | null;
  /**
   * External ID for the STS AssumeRole call, unique per customer (auto-generated when auth_method is assume_role)
   */
  assume_role_external_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role' | 'assume_role';
  base_message?: ComplexTemplateConfigResponse | null;
  /**
   * AWS End User Messaging configuration set that routes delivery events to CloudWatch
   */
  configuration_set_name: string;
  /**
   * Custom sms-voice endpoint URL (e.g. http://localhost:8080 for the WireMock stub); leave blank for real AWS
   */
  endpoint_url?: string | null;
  /**
   * S3 bucket (same region as the sending number) where author media is re-staged for SendMediaMessage
   */
  media_bucket: string;
  /**
   * Origination phone number or identity in E.164 format (e.g., +15551234567); must be MMS-capable
   */
  phone_number: string;
  /**
   * ID of the primary End User Messaging tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * AWS region (e.g., us-west-2)
   */
  region: string;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type?: 'primary' | 'variant';
};
/**
 * ToolS3Response
 */
type ToolS3Response = S3Response & {
  tool_body_type: 's3';
};
/**
 * AuthenticatedLinkUpdateMessageTrackingRequest
 *
 * What the host serving the link prefix reports about a link's message: a status and the time it happened, as develop's update-message-tracking took them. Only the token is required
 */
type AuthenticatedLinkUpdateMessageTrackingRequest = {
  /**
   * When the recipient submitted the form. Left empty, the message keeps its value
   */
  form_submitted_at?: string | null;
  /**
   * When the host's landing page opened. Left empty, the message keeps its value
   */
  opened_at?: string | null;
  /**
   * Engagement status the host reports, typically "opened" or "form_submitted". Applied through the message's order guard, so it only ever moves the message forward
   */
  status?: string | null;
  /**
   * The token from the link's path, `<link_prefix>/<token>`
   */
  token: string;
};
/**
 * DataActivationClientSFTPCallResponse
 */
type DataActivationClientSftpCallResponse = SftpCallResponse & {
  tool_call_type: 'sftp_request';
};
/**
 * ActionRunDataActivationClientCallResponse
 */
type ActionRunDataActivationClientCallResponse = RunDataActivationClientCallResponse & {
  tool_call_type: 'run_data_activation_client';
};
/**
 * DataSourceRequest
 *
 * Data source — connection to a third-party system or API Request
 */
type DataSourceRequest = {
  /**
   * Data source description
   */
  description?: string | null;
  /**
   * Data Source ID
   */
  id?: string;
  /**
   * Image URL
   */
  image_url?: string | null;
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * Whether this is the default data source
   */
  is_default: boolean;
  /**
   * Data source name
   */
  name: string;
  /**
   * Data source status
   */
  status: 'draft' | 'active' | 'inactive';
  /**
   * Last update timestamp
   */
  updated_at?: string;
  /**
   * Data source URI
   */
  uri: string;
};
/**
 * ExecuteSqlRequest
 *
 * A read-only SQL statement to execute against the datalake, the data access mode, and
 * optional Flop-inspired pagination. `page_size` is capped server-side.
 *
 */
type ExecuteSqlRequest = {
  /**
   * Which lake to query: `raw`, `tokenized` or `redacted`
   */
  mode: 'raw' | 'tokenized' | 'redacted';
  /**
   * 1-based page number
   */
  page?: number | null;
  /**
   * Rows per page (capped at the server's default page size)
   */
  page_size?: number | null;
  /**
   * Read-only SQL statement to execute
   */
  sql: string;
};
/**
 * ToolManualUploadRequest
 */
type ToolManualUploadRequest = ManualUploadRequest & {
  tool_body_type: 'manual_upload';
};
/**
 * ResyncTableRequest
 *
 * Which table to empty in the copy and copy again from the start
 */
type ResyncTableRequest = {
  /**
   * A table this copy carries, or one the original can send. Any other name is
   * refused — that gate is what stands between a typo and an emptied table.
   * Read `GET .../tables` for the list.
   *
   */
  table: string;
};
/**
 * ActionManualUploadCallResponse
 */
type ActionManualUploadCallResponse = ManualUploadCallResponse & {
  tool_call_type: 'manual_upload';
};
/**
 * DatalakeResponse
 *
 * Datalake configuration. Secrets (DB passwords, credentials) are write-only — accepted on create but never returned in responses.
 */
type DatalakeResponse = {
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  cloud_storage: ({
    cloud_storage_type: 'aws';
  } & DatalakeCloudStorageAwsResponse) | ({
    cloud_storage_type: 'r2';
  } & DatalakeCloudStorageR2Response) | ({
    cloud_storage_type: 'custom';
  } & DatalakeCloudStorageCustomResponse);
  /**
   * Reader auth method
   */
  db_reader_auth_method: 'password' | 'iam_role';
  /**
   * Enable SSL for reader
   */
  db_reader_enable_ssl: boolean;
  /**
   * Reader DB host. Null while a derived lake's database is still being provisioned
   */
  db_reader_host: string | null;
  /**
   * Reader DB name
   */
  db_reader_name: string;
  /**
   * Reader DB port. Null while a derived lake's database is still being provisioned
   */
  db_reader_port: number | null;
  /**
   * Reader DB schema name
   */
  db_reader_schema: string;
  /**
   * Writer auth method
   */
  db_writer_auth_method: 'password' | 'iam_role';
  /**
   * Enable SSL for writer
   */
  db_writer_enable_ssl: boolean;
  /**
   * Writer DB host. Null while a derived lake's database is still being provisioned
   */
  db_writer_host: string | null;
  /**
   * Writer DB name
   */
  db_writer_name: string;
  /**
   * Writer DB port. Null while a derived lake's database is still being provisioned
   */
  db_writer_port: number | null;
  /**
   * Writer DB schema name
   */
  db_writer_schema: string;
  /**
   * The tokenized and redacted lakes derived from this one
   */
  readonly derived_datalakes?: Array<DatalakeResponse>;
  /**
   * Datalake description
   */
  description?: string | null;
  /**
   * Datalake ID
   */
  readonly id?: string;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  /**
   * Datalake name
   */
  name: string;
  /**
   * Database connection pool size
   */
  pool_size: number | null;
  /**
   * The raw datalake this one derives from. Required on a tokenized or redacted datalake, and always null on a raw one.
   */
  primary_datalake_id?: string | null;
  /**
   * URL-friendly slug. Server-computed from `name`; read-only on the wire — clients do not author this field.
   */
  readonly slug?: string;
  /**
   * Datalake setup status
   */
  readonly status?: 'provisioning' | 'new' | 'processing' | 'ready';
  tenant?: TenantResponse;
  /**
   * Datalake reporting timezone. Closed whitelist of 8 US timezones — general IANA values (including `UTC`) are rejected.
   */
  timezone: 'America/New_York' | 'America/Chicago' | 'America/Denver' | 'America/Los_Angeles' | 'America/Anchorage' | 'America/Adak' | 'Pacific/Honolulu' | 'America/Phoenix';
  /**
   * What this lake holds. `raw` is the lake the platform writes; `tokenized` and `redacted` are derived, read-only, and filled by replication.
   */
  type?: 'raw' | 'tokenized' | 'redacted';
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
};
/**
 * AlveraAPIError
 *
 * Uniform JSON:API error response for the Alvera API. See module docs for pointer format, title/detail semantics, and pipeline error codes.
 */
type AlveraApiError = {
  /**
   * One entry per validation failure. A 422 always has at least one error; an empty array is never emitted.
   */
  errors: Array<{
    /**
     * Human-readable message. Validator `%{var}` placeholders are already interpolated server-side; pipeline errors surface the underlying cause (Liquid parser line, JSON decode position, etc.).
     */
    detail: string;
    /**
     * Locates the offending field.
     */
    source: {
      /**
       * RFC 6901 JSON Pointer. For validation errors it points into the request body (`/name`, `/items`); for `/run` pipeline errors it points into the contract field whose template produced the failure (`/template_config/body`, `/mdm_input_config/body`, `/filter_template`).
       */
      pointer: string;
    };
    /**
     * Short error category / machine-readable code. Validation errors: constant "Invalid value". Pipeline errors: stage code — "transform_failed", "mdm_input_render_failed", "template_body_missing", "filter_evaluation_failed". Clients can pattern-match on this field for programmatic dispatch.
     */
    title: string;
  }>;
  /**
   * Which derived copy failed to provision — `tokenized` or `redacted`. `null` on every other structured error, which is why it is not required. Without it a client is told a copy of the pair failed but not which one, and a copy is repaired one mode at a time.
   */
  mode?: string | null;
};
/**
 * RunDataActivationClientCallResponse
 *
 * Runs a data activation client for the row that started the workflow, with the tool call the template renders for that row in place of the client's stored one.
 */
type RunDataActivationClientCallResponse = {
  /**
   * Slug of the data activation client to run, in the workflow's datalake
   */
  client_slug: string;
  /**
   * Liquid template rendered against the row that started the workflow, to the client's whole tool call as JSON — the shape the run-manually endpoint takes. It replaces the client's stored tool call for this run only.
   */
  tool_call_override_template: string;
};
/**
 * CloudStorageAwsResponse
 *
 * AWS S3 cloud storage configuration supporting access key and IAM role authentication.
 */
type CloudStorageAwsResponse = {
  /**
   * AWS access key ID (required when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method?: 'access_key' | 'iam_role';
  /**
   * Base path prefix for objects within the bucket
   */
  base_path?: string;
  /**
   * S3 bucket name
   */
  bucket: string;
  /**
   * Custom S3 endpoint URL (optional, defaults to AWS)
   */
  endpoint?: string | null;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
};
/**
 * SFTPResponse
 *
 * SFTP (SSH File Transfer Protocol) server connection configuration with password or SSH key auth.
 */
type SftpResponse = {
  /**
   * SFTP authentication method
   */
  auth_method: 'password' | 'ssh_key';
  /**
   * Base directory path on the SFTP server
   */
  base_path: string;
  base_path_template?: ComplexTemplateConfigResponse | null;
  /**
   * SFTP server hostname or IP address
   */
  host: string;
  /**
   * SFTP port
   */
  port: number;
  /**
   * SFTP username
   */
  user_name: string;
};
/**
 * ToolSNSResponse
 */
type ToolSnsResponse = SnsResponse & {
  tool_body_type: 'sns';
};
/**
 * UserSearchRequest
 *
 * User SQL search resource. Created via `POST /datasets/:dataset/user-searches`
 * with a `WHERE`-clause body in `search_query`; the platform executes
 * `INSERT INTO search_results SELECT … WHERE <body>` to populate
 * `search_results` and reports back `status`, `results_count`, and
 * `error_message`.
 *
 * UserSearch carries no `data_access_mode` of its own — the capability check
 * runs where the lake's connection is acquired, via
 * `Platform.Datalakes.authorize_lake_access!/1`, which reads the ambient
 * session and raises 403 when the ceiling is insufficient. ExOpenApiUtils derives `UserSearchRequest` (writeable subset)
 * and `UserSearchResponse` (full readable shape) from this declaration via
 * the readOnly/writeOnly markers on each property.
 * Request
 */
type UserSearchRequest = {
  /**
   * Generic-table identifier. Required when the dataset is a generic table; must be omitted otherwise.
   */
  generic_table_id?: string | null;
  /**
   * SQL `WHERE`-clause body. The platform wraps it in `INSERT INTO search_results SELECT … WHERE <body>`. Reference the table aliases exposed by the dataset's base decomposed query (see `GET /datasets/:dataset_type/metadata`).
   */
  search_query: string;
};
/**
 * AdminApiKeyResponse
 *
 * A newly created API key's plaintext, for an admin caller.
 */
type AdminApiKeyResponse = {
  /**
   * Browser origins permitted to use this key cross-origin.
   */
  allowed_origins: Array<string>;
  /**
   * Plaintext API key — record it now, it is never shown again.
   */
  api_key: string;
  /**
   * Last 4 characters of the key.
   */
  last_four: string;
  /**
   * ID of the tenant the key belongs to.
   */
  tenant_id: string;
};
/**
 * SQLQueryCallResponse
 *
 * SQL query descriptor — Liquid-templated query body.
 */
type SqlQueryCallResponse = {
  query: SimpleTemplateConfigResponse;
};
/**
 * ComplexTemplateConfigResponse
 *
 * Inline Liquid template configuration including the rendered-output JSON Schema
 */
type ComplexTemplateConfigResponse = {
  /**
   * Liquid template body (required for :custom type)
   */
  body?: string | null;
  /**
   * JSON Schema describing expected rendered output
   */
  output_schema: {
    [key: string]: unknown;
  } | null;
  /**
   * Filesystem path (required for :system type)
   */
  path?: string | null;
  /**
   * Template resolution type
   */
  type: 'system' | 'custom' | 'identity' | 'null';
};
/**
 * ActionSFTPCallResponse
 */
type ActionSftpCallResponse = SftpCallResponse & {
  tool_call_type: 'sftp_request';
};
/**
 * ManualUploadResponse
 *
 * Manual upload marker tool — no configuration fields, just an identity marker for manual ingestion workflows.
 */
type ManualUploadResponse = {
  [key: string]: unknown;
};
/**
 * DatalakeCloudStorageR2Response
 */
type DatalakeCloudStorageR2Response = CloudStorageR2Response & {
  cloud_storage_type: 'r2';
};
/**
 * ManualToolInvocationAWSLambdaCallResponse
 */
type ManualToolInvocationAwsLambdaCallResponse = AwsLambdaCallResponse & {
  tool_call_type: 'aws_lambda_request';
};
/**
 * PingResponse
 *
 * Health check response with version and database connectivity status
 */
type PingResponse = {
  database_status: 'connected' | 'disconnected';
  /**
   * The platform's own IAM task role — the principal a customer names in the trust policy of
   * the role they create for the platform to assume (`auth_method: assume_role` on an AWS tool).
   *
   * Public by design: it has to reach every customer for onboarding to be possible. The control
   * against a confused deputy is the per-tool external ID the platform generates, not
   * concealment of this ARN. `null` where the platform runs without AWS, as in local development.
   *
   */
  iam_role_arn?: string | null;
  status: 'ok' | 'error';
  timestamp: string;
  version: string;
};
/**
 * UploadLinkResponse
 *
 * Response containing a presigned PUT URL for uploading a file to object storage
 */
type UploadLinkResponse = {
  /**
   * Seconds until the presigned URL expires
   */
  expires_in: number;
  /**
   * Storage key to use in the subsequent ingest-file call
   */
  key: string;
  /**
   * Presigned HTTPS PUT URL. The file must be uploaded with the same Content-Type that was requested.
   */
  url: string;
};
/**
 * TenantListResponse
 *
 * Paginated list of tenants
 */
type TenantListResponse = {
  /**
   * List of tenants
   */
  data: Array<TenantResponse>;
  meta: PaginationMeta;
};
/**
 * ActionEmailCallResponse
 */
type ActionEmailCallResponse = EmailCallResponse & {
  tool_call_type: 'email_request';
};
/**
 * S3Response
 *
 * S3-compatible storage tool configuration with a nested polymorphic provider config (AWS or R2).
 */
type S3Response = {
  base_prefix?: ComplexTemplateConfigResponse | null;
  config: ({
    storage_config_type: 'aws';
  } & S3CloudStorageAwsResponse) | ({
    storage_config_type: 'r2';
  } & S3CloudStorageR2Response);
};
/**
 * RunWorkflowRequest
 *
 * Request body for bulk workflow execution via SQL WHERE clause
 */
type RunWorkflowRequest = {
  /**
   * When true, bypasses dedupe and idempotency key checks so actions can fire again for the same record. Defaults to false.
   */
  manual_override?: boolean;
  /**
   * Execution mode. 'live' fires real tool calls; 'dry_run' runs the full pipeline without making external calls.
   */
  mode?: 'live' | 'dry_run';
  /**
   * When the run should fire, as an ISO-8601 timestamp **with an offset** (e.g. "2026-08-12T09:00:00Z"). Omit to fire as soon as a worker picks it up. The segment is resolved when the run fires, not when it is scheduled, so a run scheduled for Friday reaches Friday's matches. Each action still passes through the workflow's action window, so an action may execute later than this.
   */
  scheduled_at?: string | null;
  /**
   * SQL WHERE clause to filter dataset records (e.g. "status = 'active'")
   */
  sql_where_clause: string;
};
/**
 * SFTPCallRequest
 *
 * SFTP file descriptor — remote path + expected MIME content type. Request
 */
type SftpCallRequest = {
  /**
   * Expected MIME content type (e.g. application/json)
   */
  content_type: string;
  /**
   * Remote file path on the SFTP server
   */
  path: string;
};
/**
 * ManualToolInvocationRESTCallResponse
 */
type ManualToolInvocationRestCallResponse = RestCallResponse & {
  tool_call_type: 'restapi_request';
};
/**
 * SessionResponse
 *
 * Authenticated session — issued at sign-in (`POST /api/v1/sessions`) or
 * derived from an `X-API-Key` header. The `session_token` field carries the
 * plaintext Bearer on creation responses and is null on verify responses.
 * `tenant`, `role`, and `user` are nullable for tenant-less / pre-tenant
 * sessions; `api_key` is populated for M2M sessions only.
 *
 */
type SessionResponse = {
  api_key?: ApiKeyResponse;
  /**
   * Capability ceiling for the session — the most sensitive lake it may read. `:raw` reaches the raw lake, which holds real PHI/PII values; `:tokenized` and `:redacted` name derived lakes, which hold none. Set at creation time from the membership role: a researcher is capped at `:tokenized` and can never reach the raw lake, while an admin or member is capped at `:raw`. Cannot be widened post-creation.
   */
  data_access_mode: 'raw' | 'tokenized' | 'redacted';
  /**
   * Expiration timestamp (null for non-expiring M2M sessions)
   */
  readonly expires_at?: string | null;
  /**
   * Session ID
   */
  readonly id?: string;
  role?: RoleResponse;
  /**
   * Plaintext Bearer token. Returned only on creation; null on verify (token is not re-exposed).
   */
  readonly session_token?: string | null;
  tenant?: TenantResponse;
  /**
   * Session type
   */
  readonly type: 'user' | 'api';
  user?: UserResponse;
};
/**
 * AdvancedMigrationListResponse
 *
 * Paginated list of advanced migrations
 */
type AdvancedMigrationListResponse = {
  /**
   * List of advanced migrations
   */
  data: Array<AdvancedMigrationResponse>;
  meta: PaginationMeta;
};
/**
 * ActionStatusUpdaterCloudWatchQueryRequest
 */
type ActionStatusUpdaterCloudWatchQueryRequest = CloudWatchQueryRequest & {
  updater_body_type: 'cloud_watch_request';
};
/**
 * ActionStatusUpdaterRESTCallRequest
 */
type ActionStatusUpdaterRestCallRequest = RestCallRequest & {
  updater_body_type: 'restapi_request';
};
/**
 * IngestResponse
 *
 * Response from data ingestion
 */
type IngestResponse = {
  /**
   * Batch ID for tracking
   */
  batch_id: string;
  /**
   * Number of processing jobs created
   */
  jobs_count: number;
  /**
   * Storage key for the ingested data
   */
  key: string;
};
/**
 * DataActivationClientAWSLambdaCallResponse
 */
type DataActivationClientAwsLambdaCallResponse = AwsLambdaCallResponse & {
  tool_call_type: 'aws_lambda_request';
};
/**
 * ToolResponse
 *
 * Tool — a configurable capability reference for external services.
 */
type ToolResponse = {
  body?: ({
    tool_body_type: 'email';
  } & ToolEmailResponse) | ({
    tool_body_type: 'sns';
  } & ToolSnsResponse) | ({
    tool_body_type: 'twilio';
  } & ToolTwilioResponse) | ({
    tool_body_type: 'end_user_messaging';
  } & ToolEndUserMessagingResponse) | ({
    tool_body_type: 'rest_api';
  } & ToolRestapiResponse) | ({
    tool_body_type: 's3';
  } & ToolS3Response) | ({
    tool_body_type: 'aws_lambda';
  } & ToolAwsLambdaResponse) | ({
    tool_body_type: 'sql_database';
  } & ToolSqlDatabaseResponse) | ({
    tool_body_type: 'sqs';
  } & ToolSqsResponse) | ({
    tool_body_type: 'sftp';
  } & ToolSftpResponse) | ({
    tool_body_type: 'sharepoint';
  } & ToolSharePointResponse) | ({
    tool_body_type: 'cloud_watch_log_group';
  } & ToolCloudWatchLogGroupResponse) | ({
    tool_body_type: 'manual_upload';
  } & ToolManualUploadResponse);
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * Data Source ID
   */
  data_source_id?: string | null;
  /**
   * Datalake ID
   */
  datalake_id?: string;
  /**
   * Tool description
   */
  description?: string | null;
  /**
   * Tool ID
   */
  readonly id?: string;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  intent?: ToolIntent;
  /**
   * Tool name
   */
  name?: string;
  response_extractor?: ComplexTemplateConfigResponse | null;
  /**
   * Tool status
   */
  status?: 'draft' | 'active' | 'inactive' | 'error' | 'marked_for_deletion';
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
};
/**
 * IngestFileResponse
 *
 * Response from scheduling a bulk file ingest. Row extraction and per-row processing jobs are created asynchronously by the EnqueueRows worker.
 */
type IngestFileResponse = {
  /**
   * Oban job id of the scheduled EnqueueRows job
   */
  job_id: number;
  /**
   * Storage key that was accepted for ingestion
   */
  key: string;
  /**
   * Initial state of the scheduled job (typically "scheduled" or "available")
   */
  status: string;
};
/**
 * DataSourceListResponse
 *
 * Paginated list of data sources
 */
type DataSourceListResponse = {
  /**
   * List of data sources
   */
  data: Array<DataSourceResponse>;
  meta: PaginationMeta;
};
/**
 * ActionManualUploadCallRequest
 */
type ActionManualUploadCallRequest = ManualUploadCallRequest & {
  tool_call_type: 'manual_upload';
};
/**
 * SharePointExcelCallResponse
 *
 * Microsoft SharePoint request descriptor — drive URL + Excel sheet + search params.
 */
type SharePointExcelCallResponse = {
  /**
   * Microsoft Azure tenant identifier (UUID)
   */
  azure_tenant_id: string;
  /**
   * SharePoint drive URL
   */
  drive_url: string;
  /**
   * Search parameters applied when locating files
   */
  search_params: string;
  /**
   * Excel sheet number (0-indexed) within the workbook
   */
  sheet_number: number;
};
/**
 * SNSResponse
 *
 * AWS SNS tool configuration for sending SMS messages via the SNS Publish API.
 */
type SnsResponse = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * IAM role ARN to assume in the customer's AWS account (used when auth_method is assume_role)
   */
  assume_role_arn?: string | null;
  /**
   * External ID for the STS AssumeRole call, unique per customer (auto-generated when auth_method is assume_role)
   */
  assume_role_external_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role' | 'assume_role';
  base_message?: ComplexTemplateConfigResponse | null;
  /**
   * Custom SNS endpoint URL (e.g., http://localhost:4566 for MiniStack); leave blank for real AWS
   */
  endpoint_url?: string | null;
  /**
   * Origination phone number in E.164 format (e.g., +15551234567)
   */
  phone_number: string;
  /**
   * ID of the primary SNS tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type?: 'primary' | 'variant';
};
/**
 * InteroperabilityContractAiAgentResponse
 *
 * Join entry linking an AI agent to an interoperability contract at a specific execution position in the enrichment pipeline.
 */
type InteroperabilityContractAiAgentResponse = {
  ai_agent?: MinimalAiAgentResponse;
  /**
   * AI agent ID
   */
  ai_agent_id: string;
  context_mapping_config: ComplexTemplateConfigResponse;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  /**
   * Execution order in the enrichment pipeline
   */
  position: number;
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
};
/**
 * InteroperabilityRunRequest
 *
 * Raw source-row payload to run through a contract's filter → transform → mdm_input pipeline. Stateless: no DB writes. Accepts arbitrary keys by design — validation is deferred to the contract.
 */
type InteroperabilityRunRequest = {
  [key: string]: unknown;
};
/**
 * DatalakeMigrateResponse
 *
 * Accepted response for an enqueued datalake migration job
 */
type DatalakeMigrateResponse = {
  /**
   * Datalake whose schemas will be migrated
   */
  datalake_id: string;
  /**
   * When the job was enqueued
   */
  enqueued_at: string;
  /**
   * Oban job ID for tracking. This datalake's own job — the first of the batch. The derived lakes are migrated by their own jobs, which are not reported here.
   */
  job_id: number;
  /**
   * Always the literal `enqueued` — a constant in the response body, not a
   * reading of the job's state. A repeat call while a job for this datalake
   * is still incomplete is deduplicated onto the existing job, so `job_id`
   * and `enqueued_at` can describe an earlier request while this field
   * still reads `enqueued`. Poll `GET /datalakes/:id` for real progress.
   *
   */
  status: 'enqueued';
};
/**
 * RESTCallRequest
 *
 * REST API call descriptor — HTTP method, path, body, params, pagination context template, and events extraction template. Reused across ActionStatusUpdater polling, data activation clients, tool protocols, OAuth token fetching, and chat completion; events_template is the status-poll extraction concern and is required only there. Request
 */
type RestCallRequest = {
  body?: SimpleTemplateConfigRequest;
  events_template?: SimpleTemplateConfigRequest;
  /**
   * HTTP method
   */
  method: 'head' | 'get' | 'put' | 'post' | 'delete' | 'patch';
  pagination_context_template: SimpleTemplateConfigRequest;
  params?: SimpleTemplateConfigRequest;
  path: SimpleTemplateConfigRequest;
};
/**
 * SQLDatabaseResponse
 *
 * SQL database connection configuration (PostgreSQL, MySQL, MSSQL, SQLite, Snowflake).
 */
type SqlDatabaseResponse = {
  base_query?: ComplexTemplateConfigResponse | null;
  /**
   * Database host (hostname or IP address)
   */
  db_host: string;
  /**
   * Database name
   */
  db_name: string;
  /**
   * SQL database engine
   */
  db_type: 'postgres' | 'mysql' | 'mssql' | 'sqlite' | 'snowflake';
  /**
   * Ecto connection pool size
   */
  pool_size?: number | null;
  /**
   * Database port (defaults based on db_type: postgres=5432, mysql=3306, mssql=1433)
   */
  port?: number | null;
  /**
   * Enable SSL connection
   */
  ssl?: boolean | null;
  /**
   * SSL mode (e.g., 'require', 'verify-full')
   */
  ssl_mode?: string | null;
  /**
   * Database username
   */
  user_name: string;
};
/**
 * MDMVerifyResponse
 *
 * A legal entity that verified against its master record
 */
type MdmVerifyResponse = {
  /**
   * The verified legal entity id
   */
  legal_entity_id: string;
  status: 'verified';
  /**
   * Timestamp of verification
   */
  verified_at: string;
};
/**
 * S3CloudStorageAwsResponse
 */
type S3CloudStorageAwsResponse = CloudStorageAwsResponse & {
  storage_config_type: 'aws';
};
/**
 * S3CloudStorageR2Response
 */
type S3CloudStorageR2Response = CloudStorageR2Response & {
  storage_config_type: 'r2';
};
/**
 * ToolEmailResponse
 */
type ToolEmailResponse = EmailResponse & {
  tool_body_type: 'email';
};
/**
 * ToolListResponse
 *
 * Paginated list of tools
 */
type ToolListResponse = {
  /**
   * List of tools
   */
  data: Array<ToolResponse>;
  meta: PaginationMeta;
};
/**
 * ManualToolInvocationSQLQueryCallResponse
 */
type ManualToolInvocationSqlQueryCallResponse = SqlQueryCallResponse & {
  tool_call_type: 'sql_query';
};
/**
 * SQSResponse
 *
 * AWS SQS (Simple Queue Service) tool configuration for sending and receiving queue messages.
 */
type SqsResponse = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role';
  base_message?: ComplexTemplateConfigResponse | null;
  /**
   * Whether the queue is a FIFO queue (URL must end with .fifo)
   */
  fifo?: boolean;
  /**
   * Optional human-readable queue name for identification
   */
  queue_name?: string | null;
  /**
   * Full SQS queue URL
   */
  queue_url: string;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
};
/**
 * DataActivationClientBatchListResponse
 *
 * Paginated list of data activation client runs
 */
type DataActivationClientBatchListResponse = {
  /**
   * List of data activation client runs
   */
  data: Array<DataActivationClientBatchResponse>;
  meta: PaginationMeta;
};
/**
 * PaginationMeta
 *
 * Pagination metadata for list responses
 */
type PaginationMeta = {
  /**
   * Current page number (1-indexed)
   */
  page: number;
  /**
   * Number of items per page
   */
  page_size: number;
  /**
   * Total number of items across all pages
   */
  total_count: number;
  /**
   * Total number of pages
   */
  total_pages: number;
};
/**
 * DataActivationClientSharePointExcelCallResponse
 */
type DataActivationClientSharePointExcelCallResponse = SharePointExcelCallResponse & {
  tool_call_type: 'microsoft_share_point_excel_request';
};
/**
 * EmailResponse
 *
 * Email tool configuration — SES, Mailgun, SendGrid, SMTP, or mock (dev mailbox) provider plus base Liquid templates.
 */
type EmailResponse = {
  /**
   * AWS access key ID (SES)
   */
  access_key_id?: string;
  /**
   * Sending domain (Mailgun)
   */
  domain?: string;
  /**
   * Custom provider endpoint; leave blank for the real provider. For SES, the whole request URL (e.g., http://localhost:4566 for MiniStack); blank means https://email.<region>.amazonaws.com. For Mailgun, the API base URL (e.g., https://api.eu.mailgun.net/v3 for EU domains, or a WireMock endpoint for integration tests)
   */
  endpoint_url?: string | null;
  /**
   * Default sender email address
   */
  from_email: string;
  /**
   * Default sender display name
   */
  from_name?: string | null;
  /**
   * ID of the primary Email tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * Email provider (mock = in-process dev mailbox, no credentials)
   */
  provider: 'ses' | 'mailgun' | 'sendgrid' | 'smtp' | 'mock';
  /**
   * AWS region (SES)
   */
  region?: string;
  /**
   * Default reply-to address
   */
  reply_to?: string | null;
  /**
   * SMTP server hostname
   */
  smtp_host?: string;
  /**
   * SMTP server port
   */
  smtp_port?: number;
  /**
   * SMTP username
   */
  smtp_username?: string;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type?: 'primary' | 'variant';
};
/**
 * ManualToolInvocationMMSCallResponse
 */
type ManualToolInvocationMmsCallResponse = MmsCallResponse & {
  tool_call_type: 'mms_request';
};
/**
 * WorkflowLogResponse
 *
 * Workflow execution log — per-event execution detail
 */
type WorkflowLogResponse = {
  /**
   * Per-action execution logs scheduled under this WEL (response only, preloaded server-side)
   */
  readonly action_execution_logs?: Array<ActionExecutionLogResponse>;
  /**
   * Completed action count
   */
  actions_completed?: number;
  /**
   * Actions that have started and not finished. A run showing `actions_pending: 1, actions_executing: 0` is waiting to be picked up; one showing `actions_pending: 1, actions_executing: 1` is mid-flight and may be stuck.
   */
  actions_executing?: number;
  /**
   * Failed action count
   */
  actions_failed?: number;
  /**
   * Unfinished action count — actions still queued plus actions already running. `actions_executing` is the running share of it.
   */
  actions_pending?: number;
  /**
   * Total action count
   */
  actions_total?: number;
  /**
   * Batch identifier
   */
  batch_id?: string | null;
  completed_at?: string | null;
  /**
   * R2 storage key for context JSON
   */
  context_cloud_storage_key?: string | null;
  /**
   * Datalake ID
   */
  datalake_id?: string;
  /**
   * Error description
   */
  error_message?: string | null;
  /**
   * Whether the filter passed
   */
  filter_result?: boolean | null;
  /**
   * Execution log ID
   */
  id?: string;
  inserted_at?: string;
  /**
   * The legal entity this run is about (cross-database id)
   */
  legal_entity_id?: string | null;
  /**
   * Execution mode
   */
  mode: 'live' | 'dry_run';
  /**
   * Sampled event ID
   */
  sampled_event_id?: string | null;
  started_at?: string | null;
  /**
   * Execution status
   */
  status: 'filtered' | 'pending' | 'executing' | 'completed' | 'failed' | 'partial';
  /**
   * Tenant ID
   */
  tenant_id?: string;
  /**
   * Parent workflow ID
   */
  workflow_id?: string;
};
/**
 * AiAgentInvokeResponse
 *
 * Response from an AI agent invocation containing the parsed output and usage telemetry.
 */
type AiAgentInvokeResponse = {
  /**
   * The model's reasoning trace, when the tool's response_extractor mapped one out (thinking-enabled providers); null otherwise.
   */
  explanation?: string | null;
  /**
   * Parsed JSON output from the agent's LLM response.
   */
  output: {
    [key: string]: unknown;
  };
  /**
   * Token usage and latency telemetry for the invocation.
   */
  usage: {
    /**
     * Number of input/prompt tokens consumed.
     */
    input_tokens?: number | null;
    /**
     * End-to-end execution latency in milliseconds.
     */
    latency_ms: number;
    /**
     * LLM model identifier used for this invocation.
     */
    model?: string | null;
    /**
     * Number of output/completion tokens generated.
     */
    output_tokens?: number | null;
    /**
     * Total tokens (input + output).
     */
    total_tokens?: number | null;
  };
};
/**
 * AuthenticatedLinkResponse
 *
 * An authenticated link, with the message it was sent in
 */
type AuthenticatedLinkResponse = {
  /**
   * The workflow action that sent the message
   */
  readonly action_id: string;
  /**
   * The URL as written in the message
   */
  readonly destination_url: string;
  /**
   * When the link stops resolving
   */
  readonly expires_at: string;
  /**
   * The recipient's legal entity, when MDM resolved one
   */
  readonly legal_entity_id?: string | null;
  /**
   * When a person first clicked this link; empty until then
   */
  readonly link_clicked_at?: string | null;
  message: MessageResponse;
  /**
   * The message the link was sent in
   */
  readonly message_id: string;
  /**
   * The workflow run that sent the message
   */
  readonly workflow_execution_log_id: string;
  /**
   * The workflow that sent the message
   */
  readonly workflow_id: string;
};
/**
 * ToolSQSResponse
 */
type ToolSqsResponse = SqsResponse & {
  tool_body_type: 'sqs';
};
/**
 * ApiKeyResponse
 *
 * Lean API key reference — id, name, last_four, and data_access_mode (no plaintext)
 */
type ApiKeyResponse = {
  /**
   * Capability ceiling baked into the key — the most sensitive lake a session derived from it may read. `:raw` reaches the raw lake, which holds real PHI/PII values; `:tokenized` and `:redacted` name derived lakes, which hold none. Sessions derived from this key inherit this value. Cannot be widened post-creation — revoke + re-mint instead.
   */
  data_access_mode: 'raw' | 'tokenized' | 'redacted';
  /**
   * API key ID
   */
  readonly id: string;
  /**
   * Last 4 characters of the key
   */
  readonly last_four: string;
  /**
   * API key name
   */
  name: string;
};
/**
 * DataActivationClientResponse
 *
 * Data Activation Client — binds a (datalake, data_source, tool) triple with a polymorphic `tool_call` config describing how to fetch data from the external system, plus optional cron schedule, row-level filter, downstream triggers, and interop contracts for row-level transformation.
 */
type DataActivationClientResponse = {
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * Cron expressions (Crontab syntax, array). Examples: ["0 *6 * * *"] for every 6 hours. Omit for on-demand clients.
   */
  cron_expressions?: Array<string>;
  /**
   * Owning data source ID
   */
  data_source_id: string;
  /**
   * Owning datalake ID (matches :datalake_slug path segment)
   */
  readonly datalake_id?: string;
  /**
   * DAC description
   */
  description?: string | null;
  /**
   * IDs of downstream DACs triggered after this one completes
   */
  downstream_connection_ids?: Array<string>;
  filter_config?: SimpleTemplateConfigResponse | null;
  /**
   * DAC ID
   */
  readonly id?: string;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  /**
   * IDs of interoperability contracts used to transform each fetched row
   */
  interoperability_contract_ids?: Array<string>;
  /**
   * True for platform-created default DACs. Cannot be deleted.
   */
  readonly is_default?: boolean;
  /**
   * DAC name
   */
  name: string;
  /**
   * Optional row-level Liquid pre-filter. Renders to empty/whitespace → row passes; any non-empty trimmed render → row is skipped (rendered string is the skip reason). Nil/empty body = no filter. Same semantics as InteroperabilityContract.filter_template.
   */
  row_filter?: string | null;
  rows_from_file_template?: SimpleTemplateConfigResponse | null;
  /**
   * URL-friendly slug (derived from name on insert; immutable)
   */
  readonly slug?: string;
  tool_call: ({
    tool_call_type: 'restapi_request';
  } & DataActivationClientRestCallResponse) | ({
    tool_call_type: 'sql_query';
  } & DataActivationClientSqlQueryCallResponse) | ({
    tool_call_type: 'sftp_request';
  } & DataActivationClientSftpCallResponse) | ({
    tool_call_type: 'microsoft_share_point_excel_request';
  } & DataActivationClientSharePointExcelCallResponse) | ({
    tool_call_type: 'aws_lambda_request';
  } & DataActivationClientAwsLambdaCallResponse) | ({
    tool_call_type: 'manual_upload';
  } & DataActivationClientManualUploadCallResponse) | ({
    tool_call_type: 's3_request';
  } & DataActivationClientS3CallResponse);
  /**
   * Owning tool ID
   */
  tool_id: string;
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
};
/**
 * DatalakeListResponse
 *
 * Paginated list of datalakes
 */
type DatalakeListResponse = {
  /**
   * List of datalakes
   */
  data: Array<DatalakeResponse>;
  meta: PaginationMeta;
};
/**
 * RunWorkflowResponse
 *
 * Acknowledgement that a run has been scheduled.
 *
 * **Changed in 0.23.0.** This endpoint used to run the workflow inline and
 * return `enqueued_count`, `batch_id` and `workflow_run_log_id`. It now records
 * a workflow run and returns immediately, so none of those three are knowable
 * yet: the segment is resolved when the run fires, and the batch it produces
 * does not exist until then. Read them from the run via
 * `GET /tenants/{tenant_slug}/datalakes/{datalake_slug}/workflow-runs/{id}`
 * once its status leaves `scheduled`.
 *
 */
type RunWorkflowResponse = {
  /**
   * How many records the clause matched **when it was scheduled**. A preview for sanity-checking the clause, not the audience: the segment is resolved again at send time, and suppressed records are excluded then.
   */
  matched_count?: number | null;
  /**
   * When the run will fire. Echoes the requested time, or the time the request was received when none was given.
   */
  scheduled_at: string;
  /**
   * Run state at the moment of this response — always `scheduled` here.
   */
  status: 'scheduled' | 'processing' | 'completed' | 'cancelled' | 'failed';
  /**
   * The scheduled run. Use it to poll status, or to cancel while still `scheduled`.
   */
  workflow_run_id: string;
};
/**
 * ExecuteActionResponse
 *
 * Response from executing a workflow action
 */
type ExecuteActionResponse = {
  /**
   * Number of action executions scheduled
   */
  scheduled_count?: number;
  /**
   * Oban job id of the scheduled action execution. Nil when no job was scheduled (e.g. an invalid `trigger_template` produced a failed ActionExecutionLog instead).
   */
  scheduled_job_id?: number | null;
  /**
   * Current status of the workflow execution
   */
  status?: 'pending' | 'completed' | 'filtered' | 'failed';
  /**
   * ID of the workflow execution log (nil when async, populated when synchronous)
   */
  workflow_execution_log_id?: string | null;
};
/**
 * DatalakeCloudStorageAwsResponse
 */
type DatalakeCloudStorageAwsResponse = CloudStorageAwsResponse & {
  cloud_storage_type: 'aws';
};
/**
 * ActionRESTCallResponse
 */
type ActionRestCallResponse = RestCallResponse & {
  tool_call_type: 'restapi_request';
};
/**
 * IngestFileRequest
 *
 * Request body for ingesting a file that was previously uploaded via a presigned upload link
 */
type IngestFileRequest = {
  /**
   * Optional business attributes merged into each row extracted from the uploaded file. For a document upload (image/PDF) the extracted row is just `{r2_key, content_type}`; these attrs ride alongside it (e.g. account_holder_number) so the interop contract can resolve the legal entity. File-derived keys (`r2_key`, `content_type`) always win over `data`.
   */
  data?: {
    [key: string]: unknown;
  } | null;
  /**
   * Storage key returned from the upload-link endpoint. Must belong to the same data activation client.
   */
  key: string;
};
/**
 * ExecuteSqlResponse
 *
 * Read-only SQL result. `data` is the page of rows as an array-of-arrays (tabular, since
 * arbitrary SQL can have duplicate or expression column names that object keys would
 * collapse); the column names and pagination live in `meta`.
 *
 */
type ExecuteSqlResponse = {
  /**
   * Page of result rows; each row is an array of cell values aligned to `meta.columns`
   */
  data: Array<Array<unknown>>;
  meta: ExecuteSqlMeta;
};
/**
 * ToolCloudWatchLogGroupResponse
 */
type ToolCloudWatchLogGroupResponse = CloudWatchLogGroupResponse & {
  tool_body_type: 'cloud_watch_log_group';
};
/**
 * TwilioRequest
 *
 * Twilio tool configuration for sending SMS and MMS via the Programmable Messaging API. A primary holds the account credential; a variant names its primary and carries only its own sender identity. Request
 */
type TwilioRequest = {
  /**
   * Twilio Account SID (required on a primary; supplied by the primary on a variant)
   */
  account_sid?: string | null;
  /**
   * Twilio API Key SID (required when auth_method is api_key)
   */
  api_key_sid?: string | null;
  /**
   * How this primary authenticates to Twilio. Defaults to auth_token.
   */
  auth_method?: 'auth_token' | 'api_key';
  base_message?: ComplexTemplateConfigRequest;
  /**
   * Custom Twilio API base URL (e.g., http://localhost:8080 for WireMock); leave blank for https://api.twilio.com
   */
  base_url?: string | null;
  /**
   * Origination phone number in E.164 format (e.g., +15551234567)
   */
  from_number?: string | null;
  /**
   * Twilio Messaging Service SID, used instead of a from_number
   */
  messaging_service_sid?: string | null;
  /**
   * ID of the primary Twilio tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * Request timeout in milliseconds (1–300000)
   */
  timeout_ms?: number | null;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type: 'primary' | 'variant';
};
/**
 * CloudWatchQueryRequest
 *
 * CloudWatch log group query descriptor — log group name plus Liquid-templated time window. Reusable across any caller that needs CloudWatch polling (currently ActionStatusUpdater.updater_body). Title is CloudWatchQuery (not CloudWatchRequest) to avoid triple-`Request` stacking in the library-generated parent-contextual sibling module names (e.g. ActionStatusUpdaterCloudWatchQueryRequest). Request
 */
type CloudWatchQueryRequest = {
  /**
   * Liquid template for the poll window end time, rendered with `{{ now_msec }}` in unix milliseconds (e.g., "{{ now_msec }}")
   */
  end_time: string;
  /**
   * CloudWatch log group name to poll for delivery events
   */
  log_group_name: string;
  /**
   * Liquid template for the poll window start time, rendered with `{{ now }}` in unix milliseconds (e.g., "{{ now_msec | minutes_ago: 45 }}")
   */
  start_time: string;
};
/**
 * GenericTableResponse
 *
 * Generic Table — custom or system dataset table with column definitions.
 */
type GenericTableResponse = {
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * Table column definitions
   */
  readonly columns?: Array<GenericTableColumnResponse>;
  /**
   * Datalake ID
   */
  readonly datalake_id?: string;
  /**
   * Table description
   */
  description?: string;
  /**
   * Generic Table ID
   */
  readonly id?: string;
  /**
   * Creation timestamp
   */
  readonly inserted_at?: string;
  /**
   * Auto-generated table name (from title)
   */
  readonly name?: string;
  /**
   * Table deployment status
   */
  readonly status?: 'new' | 'stale' | 'processing' | 'deployed';
  /**
   * Tenant ID
   */
  readonly tenant_id?: string;
  /**
   * User-friendly table title
   */
  title?: string;
  /**
   * Table type
   */
  readonly type?: 'custom' | 'system';
  /**
   * Last update timestamp
   */
  readonly updated_at?: string;
};
/**
 * InteroperabilityContractListResponse
 *
 * Paginated list of interoperability contracts
 */
type InteroperabilityContractListResponse = {
  /**
   * List of interoperability contracts
   */
  data: Array<InteroperabilityContractResponse>;
  meta: PaginationMeta;
};
/**
 * ToolEndUserMessagingResponse
 */
type ToolEndUserMessagingResponse = EndUserMessagingResponse & {
  tool_body_type: 'end_user_messaging';
};
/**
 * TenantRequest
 *
 * Tenant resource. The auto-generated `TenantRequest` shape carries only
 * the writable fields (`name`, `description`); `TenantResponse` returns the
 * full read surface (`id`, `slug`, `name`, `description`).
 * Request
 */
type TenantRequest = {
  /**
   * Optional free-text description; max 1000 chars.
   */
  description?: string | null;
  /**
   * Human-readable tenant name. Required on create; max 160 chars.
   */
  name: string;
};
/**
 * ActionStatusUpdaterListResponse
 *
 * Paginated list of action status updaters
 */
type ActionStatusUpdaterListResponse = {
  /**
   * List of action status updaters
   */
  data: Array<ActionStatusUpdaterResponse>;
  meta: PaginationMeta;
};
/**
 * TextToSqlResponse
 *
 * Generated SQL for a natural-language prompt. `explanation` is a best-effort plain-language
 * description of the SQL (`null` if the explainer was unavailable). The SQL is returned for
 * review/editing; run it via `POST .../execute-sql`.
 *
 */
type TextToSqlResponse = {
  /**
   * Plain-language explanation of what the SQL does; null when unavailable
   */
  explanation: string | null;
  /**
   * The model that produced the SQL (e.g. `anthropic:claude-opus-4`)
   */
  model: string;
  /**
   * The provider that produced the SQL (e.g. `anthropic`, `ollama`)
   */
  provider: string;
  /**
   * The generated SQL statement
   */
  sql: string;
};
/**
 * AgenticWorkflowListResponse
 *
 * Paginated list of agentic workflows
 */
type AgenticWorkflowListResponse = {
  /**
   * List of agentic workflows
   */
  data: Array<AgenticWorkflowResponse>;
  meta: PaginationMeta;
};
/**
 * RoleResponse
 *
 * Lean role reference — id, name, and description
 */
type RoleResponse = {
  /**
   * Role description
   */
  description?: string | null;
  /**
   * Role ID
   */
  readonly id: string;
  /**
   * Role name (e.g. tenant_admin, platform_admin)
   */
  name: string;
};
/**
 * BatchLogListResponse
 *
 * Paginated list of batch run logs
 */
type BatchLogListResponse = {
  /**
   * List of batch run logs
   */
  data: Array<BatchLogResponse>;
  meta: PaginationMeta;
};
/**
 * RunManuallyResponse
 *
 * Acknowledgement of an enqueued manual run. The `batch_id` can be used to poll per-dataset processing logs (via upcoming runs list/show endpoints).
 */
type RunManuallyResponse = {
  /**
   * Batch ID stamped on every Oban job for this run
   */
  batch_id: string;
};
/**
 * ToolTwilioResponse
 */
type ToolTwilioResponse = TwilioResponse & {
  tool_body_type: 'twilio';
};
/**
 * ToolSFTPResponse
 */
type ToolSftpResponse = SftpResponse & {
  tool_body_type: 'sftp';
};
/**
 * ResyncTableResponse
 *
 * The repair was accepted and a fresh copy has started. It finishes later —
 * poll `GET .../tables` and wait for the table to read `caught_up`.
 *
 */
type ResyncTableResponse = {
  /**
   * Every table the repair emptied — the one asked for, plus anything that
   * points at it, read from the catalog for this call. All of them are copied
   * again by the same run. Returned in full because a caller that emptied nine
   * tables should be told nine.
   *
   */
  emptied: Array<string>;
  /**
   * Which copy was repaired
   */
  mode: 'tokenized' | 'redacted';
  /**
   * Always the literal `copying` — a constant written once the repair's last
   * statement succeeded, not a reading of the copy. Nothing here queries the
   * subscription. `copying` is *also* one of the real table states
   * `GET .../tables` reports, and the two are unrelated: a table that has just
   * been put back on the subscription usually reads `waiting_to_start` for a
   * moment first. Poll `GET .../tables` for the state the copy is actually in.
   *
   */
  status: 'copying';
  /**
   * The table asked for
   */
  table: string;
};
/**
 * GenericTableColumnRequest
 *
 * Generic table column definition. Request
 */
type GenericTableColumnRequest = {
  /**
   * Column description
   */
  description: string;
  is_array?: boolean;
  is_checksum?: boolean;
  is_required?: boolean;
  is_unique?: boolean;
  /**
   * Column name
   */
  name: string;
  privacy_requirement?: 'none' | 'redact' | 'tokenize';
  /**
   * What the column holds, as opposed to how it is stored. Nullable.
   */
  semantic_kind?: 'string' | 'text' | 'email' | 'phone' | 'date' | 'json' | 'image' | 'pdf' | 'attachment';
  /**
   * Display title
   */
  title: string;
  /**
   * Column data type
   */
  type: 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'datetime' | 'time' | 'decimal' | 'jsonb' | 'uuid';
};
/**
 * CloudWatchQueryResponse
 *
 * CloudWatch log group query descriptor — log group name plus Liquid-templated time window. Reusable across any caller that needs CloudWatch polling (currently ActionStatusUpdater.updater_body). Title is CloudWatchQuery (not CloudWatchRequest) to avoid triple-`Request` stacking in the library-generated parent-contextual sibling module names (e.g. ActionStatusUpdaterCloudWatchQueryRequest).
 */
type CloudWatchQueryResponse = {
  /**
   * Liquid template for the poll window end time, rendered with `{{ now_msec }}` in unix milliseconds (e.g., "{{ now_msec }}")
   */
  end_time: string;
  /**
   * CloudWatch log group name to poll for delivery events
   */
  log_group_name: string;
  /**
   * Liquid template for the poll window start time, rendered with `{{ now }}` in unix milliseconds (e.g., "{{ now_msec | minutes_ago: 45 }}")
   */
  start_time: string;
};
/**
 * AiAgentResponse
 *
 * AI Agent configuration — reusable chat-completion resource
 */
type AiAgentResponse = {
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  /**
   * Which lake the agent reads. `tokenized` means the agent's context is read from the tokenized copy, so it never sees a real identifier. It is enforced, not advisory: an agent set to `tokenized` in an environment with no tokenized lake fails its enrichment step rather than falling back to raw.
   */
  data_access: 'raw' | 'tokenized';
  datalake?: DatalakeResponse;
  /**
   * Agent description
   */
  description?: string | null;
  /**
   * Whether the agent is enabled
   */
  enabled: boolean;
  /**
   * AI Agent ID
   */
  id?: string;
  /**
   * JSON Schema describing the agent's input contract — validated by the runner against caller context on every invocation.
   */
  input_schema: {
    [key: string]: unknown;
  };
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * JSON Schema for LLM response format
   */
  llm_response_schema: {
    [key: string]: unknown;
  } | null;
  /**
   * Maximum tokens for LLM response
   */
  max_tokens: number;
  /**
   * LLM model identifier
   */
  model: string;
  /**
   * Agent name
   */
  name: string;
  prompt_config: SimpleTemplateConfigResponse;
  /**
   * URL-friendly slug
   */
  slug?: string;
  /**
   * Sampling temperature (0.0–2.0)
   */
  temperature: number;
  tenant?: TenantResponse;
  tool?: ToolResponse;
  /**
   * Tool ID
   */
  tool_id: string;
  /**
   * Last update timestamp
   */
  updated_at?: string;
};
/**
 * InvitationListResponse
 *
 * Paginated list of invitations
 */
type InvitationListResponse = {
  /**
   * List of invitations
   */
  data: Array<InvitationResponse>;
  meta: PaginationMeta;
};
/**
 * DataActivationClientLogListResponse
 *
 * Paginated list of data activation client logs
 */
type DataActivationClientLogListResponse = {
  /**
   * List of data activation client logs
   */
  data: Array<DataActivationClientLogResponse>;
  meta: PaginationMeta;
};
/**
 * AiAgentListResponse
 *
 * Paginated list of AI agents
 */
type AiAgentListResponse = {
  /**
   * List of AI agents
   */
  data: Array<AiAgentResponse>;
  meta: PaginationMeta;
};
/**
 * AdminCreateTenantApiKeyRequest
 *
 * Attributes for an admin-provisioned public_api key.
 */
type AdminCreateTenantApiKeyRequest = {
  /**
   * Browser origins permitted to use this key cross-origin. Defaults to none.
   */
  allowed_origins?: Array<string>;
  /**
   * Capability ceiling baked into the key — see ApiKey.data_access_mode.
   */
  data_access_mode: 'raw' | 'tokenized' | 'redacted';
  /**
   * Human-readable name for the key.
   */
  name: string;
};
/**
 * CloudStorageR2Response
 *
 * Cloudflare R2 cloud storage configuration — S3-compatible with auto region and account-scoped endpoints.
 */
type CloudStorageR2Response = {
  /**
   * R2 access key ID
   */
  access_key_id: string;
  /**
   * Base path prefix for objects within the bucket
   */
  base_path?: string;
  /**
   * R2 bucket name
   */
  bucket: string;
  /**
   * Account-scoped R2 endpoint URL, e.g. https://<account-id>.r2.cloudflarestorage.com
   */
  endpoint: string;
  /**
   * R2 region (defaults to "auto")
   */
  region?: string;
};
/**
 * DataSourceResponse
 *
 * Data source — connection to a third-party system or API
 */
type DataSourceResponse = {
  /**
   * SHA-256 drift fingerprint over authored fields (server-computed)
   */
  readonly checksum?: string;
  datalake?: DatalakeResponse;
  /**
   * Data source description
   */
  description?: string | null;
  /**
   * Data Source ID
   */
  id?: string;
  /**
   * Image URL
   */
  image_url?: string | null;
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * Whether this is the default data source
   */
  is_default: boolean;
  /**
   * Data source name
   */
  name: string;
  /**
   * Data source status
   */
  status: 'draft' | 'active' | 'inactive';
  /**
   * Last update timestamp
   */
  updated_at?: string;
  /**
   * Data source URI
   */
  uri: string;
};
/**
 * AuthenticatedLinkExchangeRequest
 *
 * A tap on an authenticated link, as the host serving the link prefix forwards it: the token from `<link_prefix>/<token>` and what the tap's request said about itself. Only the token is required
 */
type AuthenticatedLinkExchangeRequest = {
  /**
   * The country the tap came from
   */
  country?: string | null;
  /**
   * The tap's request headers. A prefetch header (sec-purpose, purpose, x-purpose, x-moz) does not mark the message clicked. The tap is recorded with the client headers; never cookies or credentials
   */
  headers?: {
    [key: string]: string;
  } | null;
  /**
   * The address the tap came from
   */
  ip?: string | null;
  /**
   * The tap's HTTP method. A `HEAD` request looks automated and does not mark the message clicked
   */
  method?: string | null;
  /**
   * The token from the link's path, `<link_prefix>/<token>`
   */
  token: string;
  /**
   * The tap's User-Agent header. An empty one, or one naming a bot, link preview or mail scanner, does not mark the message clicked
   */
  user_agent?: string | null;
};
/**
 * TwilioResponse
 *
 * Twilio tool configuration for sending SMS and MMS via the Programmable Messaging API. A primary holds the account credential; a variant names its primary and carries only its own sender identity.
 */
type TwilioResponse = {
  /**
   * Twilio Account SID (required on a primary; supplied by the primary on a variant)
   */
  account_sid?: string | null;
  /**
   * Twilio API Key SID (required when auth_method is api_key)
   */
  api_key_sid?: string | null;
  /**
   * How this primary authenticates to Twilio. Defaults to auth_token.
   */
  auth_method?: 'auth_token' | 'api_key';
  base_message?: ComplexTemplateConfigResponse | null;
  /**
   * Custom Twilio API base URL (e.g., http://localhost:8080 for WireMock); leave blank for https://api.twilio.com
   */
  base_url?: string | null;
  /**
   * Origination phone number in E.164 format (e.g., +15551234567)
   */
  from_number?: string | null;
  /**
   * Twilio Messaging Service SID, used instead of a from_number
   */
  messaging_service_sid?: string | null;
  /**
   * ID of the primary Twilio tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * Request timeout in milliseconds (1–300000)
   */
  timeout_ms?: number | null;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type: 'primary' | 'variant';
};
/**
 * ToolRESTAPIResponse
 */
type ToolRestapiResponse = RestapiResponse & {
  tool_body_type: 'rest_api';
};
/**
 * DatalakeRequest
 *
 * Datalake configuration. Secrets (DB passwords, credentials) are write-only — accepted on create but never returned in responses. Request
 */
type DatalakeRequestWritable = {
  cloud_storage: ({
    cloud_storage_type: 'aws';
  } & DatalakeCloudStorageAwsRequestWritable) | ({
    cloud_storage_type: 'r2';
  } & DatalakeCloudStorageR2RequestWritable) | ({
    cloud_storage_type: 'custom';
  } & DatalakeCloudStorageCustomRequestWritable);
  /**
   * Reader auth method
   */
  db_reader_auth_method: 'password' | 'iam_role';
  /**
   * Enable SSL for reader
   */
  db_reader_enable_ssl: boolean;
  /**
   * Reader DB host. Null while a derived lake's database is still being provisioned
   */
  db_reader_host: string | null;
  /**
   * Reader DB name
   */
  db_reader_name: string;
  /**
   * Reader DB password
   */
  db_reader_pass: string;
  /**
   * Reader DB port. Null while a derived lake's database is still being provisioned
   */
  db_reader_port: number | null;
  /**
   * Reader DB schema name
   */
  db_reader_schema: string;
  /**
   * Reader DB username
   */
  db_reader_user: string;
  /**
   * Writer auth method
   */
  db_writer_auth_method: 'password' | 'iam_role';
  /**
   * Enable SSL for writer
   */
  db_writer_enable_ssl: boolean;
  /**
   * Writer DB host. Null while a derived lake's database is still being provisioned
   */
  db_writer_host: string | null;
  /**
   * Writer DB name
   */
  db_writer_name: string;
  /**
   * Writer DB password
   */
  db_writer_pass: string;
  /**
   * Writer DB port. Null while a derived lake's database is still being provisioned
   */
  db_writer_port: number | null;
  /**
   * Writer DB schema name
   */
  db_writer_schema: string;
  /**
   * Writer DB username
   */
  db_writer_user: string;
  /**
   * Datalake description
   */
  description?: string | null;
  /**
   * Datalake name
   */
  name: string;
  /**
   * Database connection pool size
   */
  pool_size: number | null;
  /**
   * The raw datalake this one derives from. Required on a tokenized or redacted datalake, and always null on a raw one.
   */
  primary_datalake_id?: string | null;
  /**
   * Datalake reporting timezone. Closed whitelist of 8 US timezones — general IANA values (including `UTC`) are rejected.
   */
  timezone: 'America/New_York' | 'America/Chicago' | 'America/Denver' | 'America/Los_Angeles' | 'America/Anchorage' | 'America/Adak' | 'Pacific/Honolulu' | 'America/Phoenix';
  /**
   * What this lake holds. `raw` is the lake the platform writes; `tokenized` and `redacted` are derived, read-only, and filled by replication.
   */
  type?: 'raw' | 'tokenized' | 'redacted';
};
/**
 * ToolRESTAPIRequest
 */
type ToolRestapiRequestWritable = RestapiRequestWritable & {
  tool_body_type: 'rest_api';
};
/**
 * EmailCallRequest
 *
 * Email tool-call config — Liquid-templated recipient, subject, and body, and the prefix its links go out on. Request
 */
type EmailCallRequestWritable = {
  body: SimpleTemplateConfigRequest;
  /**
   * Address of the host that serves this action's links. Every href in the body goes out as <link_prefix>/<token>. An absolute http or https URL, path allowed, with no query, fragment or trailing slash.
   */
  link_prefix: string;
  /**
   * How many days each link resolves after the send
   */
  link_validity_days?: number;
  subject: SimpleTemplateConfigRequest;
  to: SimpleTemplateConfigRequest;
};
/**
 * ActionEmailCallRequest
 */
type ActionEmailCallRequestWritable = EmailCallRequestWritable & {
  tool_call_type: 'email_request';
};
/**
 * ActionSMSCallRequest
 */
type ActionSmsCallRequestWritable = SmsCallRequestWritable & {
  tool_call_type: 'sms_request';
};
/**
 * DataActivationClientSharePointExcelCallRequest
 */
type DataActivationClientSharePointExcelCallRequestWritable = SharePointExcelCallRequest & {
  tool_call_type: 'microsoft_share_point_excel_request';
};
/**
 * AgenticWorkflowRequest
 *
 * Agentic Workflow — event-driven automation pipeline Request
 */
type AgenticWorkflowRequestWritable = {
  /**
   * Decision actions to attach to this workflow (request)
   */
  actions?: Array<ActionRequestWritable>;
  /**
   * Context-enrichment datasets to load before the decision stage (request)
   */
  context_datasets?: Array<ContextDatasetRequestWritable>;
  /**
   * Dataset type the workflow listens on (e.g. legal_entity, document, generic_table)
   */
  dataset_type: string;
  decision_config?: ComplexTemplateConfigRequest;
  /**
   * Workflow description
   */
  description: string;
  filter_config?: SimpleTemplateConfigRequest;
  /**
   * Generic table ID (required when dataset_type is generic_table)
   */
  generic_table_id?: string | null;
  /**
   * Workflow ID
   */
  id?: string;
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * Workflow name
   */
  name: string;
  /**
   * When true, skip MDM resolution
   */
  skip_mdm_resolution?: boolean;
  /**
   * Workflow status. live = auto-fired by event sampling; draft = preview only (dry-run); manual = never auto-fired, but runs for real when an operator explicitly invokes it.
   */
  status: 'live' | 'draft' | 'manual';
  /**
   * Operator-authored labels. Free text — no taxonomy, no shared vocabulary. Not read by the execution pipeline, but they DO participate in the workflow checksum, so retagging shifts the drift fingerprint. REQUIRED on every write. Send `[]` for an untagged workflow — deliberately no default, so an omitted key is a 422 rather than a silent reset to empty.
   */
  tags: Array<string>;
  /**
   * Last update timestamp
   */
  updated_at?: string;
  /**
   * AI agents to attach to this workflow (request)
   */
  workflow_ai_agents?: Array<WorkflowAiAgentRequestWritable>;
};
/**
 * InteroperabilityContractAiAgentRequest
 *
 * Join entry linking an AI agent to an interoperability contract at a specific execution position in the enrichment pipeline. Request
 */
type InteroperabilityContractAiAgentRequestWritable = {
  /**
   * AI agent ID
   */
  ai_agent_id: string;
  context_mapping_config: ComplexTemplateConfigRequest;
  /**
   * Execution order in the enrichment pipeline
   */
  position: number;
};
/**
 * MMSCallRequest
 *
 * MMS tool-call config — Liquid-templated recipient, optional caption, plain public media URL, and the prefix its links go out on. Request
 */
type MmsCallRequestWritable = {
  body?: SimpleTemplateConfigRequest;
  /**
   * Address of the host that serves this action's links. Every URL in the body goes out as <link_prefix>/<token>. An absolute http or https URL, path allowed, with no query, fragment or trailing slash.
   */
  link_prefix: string;
  /**
   * How many days each link resolves after the send
   */
  link_validity_days?: number;
  /**
   * Public http(s) URL of the media to attach — re-staged into the tool's S3 media bucket (End User Messaging) or fetched by Twilio directly
   */
  media_url: string;
  to: SimpleTemplateConfigRequest;
};
/**
 * EndUserMessagingRequest
 *
 * AWS End User Messaging tool configuration for sending MMS via the SendMediaMessage API. Request
 */
type EndUserMessagingRequestWritable = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * IAM role ARN to assume in the customer's AWS account (used when auth_method is assume_role)
   */
  assume_role_arn?: string | null;
  /**
   * External ID for the STS AssumeRole call, unique per customer (auto-generated when auth_method is assume_role)
   */
  assume_role_external_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role' | 'assume_role';
  base_message?: ComplexTemplateConfigRequest;
  /**
   * AWS End User Messaging configuration set that routes delivery events to CloudWatch
   */
  configuration_set_name: string;
  /**
   * Custom sms-voice endpoint URL (e.g. http://localhost:8080 for the WireMock stub); leave blank for real AWS
   */
  endpoint_url?: string | null;
  /**
   * S3 bucket (same region as the sending number) where author media is re-staged for SendMediaMessage
   */
  media_bucket: string;
  /**
   * Origination phone number or identity in E.164 format (e.g., +15551234567); must be MMS-capable
   */
  phone_number: string;
  /**
   * ID of the primary End User Messaging tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * AWS region (e.g., us-west-2)
   */
  region: string;
  /**
   * AWS secret access key (used when auth_method is access_key)
   */
  secret_access_key?: string | null;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type?: 'primary' | 'variant';
};
/**
 * ToolSharePointRequest
 */
type ToolSharePointRequestWritable = SharePointRequestWritable & {
  tool_body_type: 'sharepoint';
};
/**
 * ToolRequest
 *
 * Tool — a configurable capability reference for external services. Request
 */
type ToolRequestWritable = {
  body?: ({
    tool_body_type: 'email';
  } & ToolEmailRequestWritable) | ({
    tool_body_type: 'sns';
  } & ToolSnsRequestWritable) | ({
    tool_body_type: 'twilio';
  } & ToolTwilioRequestWritable) | ({
    tool_body_type: 'end_user_messaging';
  } & ToolEndUserMessagingRequestWritable) | ({
    tool_body_type: 'rest_api';
  } & ToolRestapiRequestWritable) | ({
    tool_body_type: 's3';
  } & ToolS3RequestWritable) | ({
    tool_body_type: 'aws_lambda';
  } & ToolAwsLambdaRequestWritable) | ({
    tool_body_type: 'sql_database';
  } & ToolSqlDatabaseRequestWritable) | ({
    tool_body_type: 'sqs';
  } & ToolSqsRequestWritable) | ({
    tool_body_type: 'sftp';
  } & ToolSftpRequestWritable) | ({
    tool_body_type: 'sharepoint';
  } & ToolSharePointRequestWritable) | ({
    tool_body_type: 'cloud_watch_log_group';
  } & ToolCloudWatchLogGroupRequestWritable) | ({
    tool_body_type: 'manual_upload';
  } & ToolManualUploadRequest);
  /**
   * Data Source ID
   */
  data_source_id?: string | null;
  /**
   * Datalake ID
   */
  datalake_id?: string;
  /**
   * Tool description
   */
  description?: string | null;
  intent?: ToolIntent;
  /**
   * Tool name
   */
  name?: string;
  response_extractor?: ComplexTemplateConfigRequest;
  /**
   * Tool status
   */
  status?: 'draft' | 'active' | 'inactive' | 'error' | 'marked_for_deletion';
};
/**
 * AWSLambdaRequest
 *
 * AWS Lambda tool configuration for an external, user-provided Lambda ARN. Request
 */
type AwsLambdaRequestWritable = {
  /**
   * AWS access key ID (required when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * Authentication method (required when type is external)
   */
  auth_method?: 'access_key' | 'iam_role' | 'cloudformation';
  base_payload?: ComplexTemplateConfigRequest;
  /**
   * User-provided environment variable key-value entries passed to the Lambda function
   */
  env_vars?: Array<unknown>;
  /**
   * Lambda function ARN
   */
  function_arn?: string | null;
  /**
   * AWS secret access key (required when auth_method is access_key)
   */
  secret_access_key?: string | null;
  /**
   * User-provided secret key-value entries synced to AWS Secrets Manager
   */
  secrets?: Array<unknown>;
  /**
   * Lambda deployment type. `external` = user-provided Lambda ARN. This is the only supported type.
   */
  type: 'external';
};
/**
 * ToolSQSRequest
 */
type ToolSqsRequestWritable = SqsRequestWritable & {
  tool_body_type: 'sqs';
};
/**
 * ActionRequest
 *
 * Workflow action — executes when the decision table routes to this `decision_key`. Polymorphic `tool_call` payload is variant-specific via `tool_call_type` discriminator. Request
 */
type ActionRequestWritable = {
  action_type: ActionType;
  /**
   * Hour (0–23) when the action's execution window closes
   */
  action_window_end?: number | null;
  /**
   * Hour (0–23) when the action's execution window opens (failsafe, typically SMS)
   */
  action_window_start?: number | null;
  /**
   * Unique decision_key within the workflow — maps to a decision-table outcome
   */
  decision_key: string;
  /**
   * Action ID — echo it back on update to modify the existing action rather than replace it
   */
  id?: string;
  /**
   * Liquid template producing the idempotency key; receives checksum, legal_entity_id, legal_entity_id, workflow_id, action_id, decision_key
   */
  idempotency_template: string;
  /**
   * Liquid template rendered to JSON once per send, on every action type. Stored on the message the send writes, and returned by the authenticated-link exchange as metadata (optional). A template that does not render fails the send.
   */
  metadata_template?: string | null;
  /**
   * Display order within the workflow
   */
  position?: number;
  /**
   * Liquid template evaluated at execution time; when falsy, the action is skipped
   */
  runtime_filter?: string | null;
  tool_call: ({
    tool_call_type: 'sms_request';
  } & ActionSmsCallRequestWritable) | ({
    tool_call_type: 'mms_request';
  } & ActionMmsCallRequestWritable) | ({
    tool_call_type: 'email_request';
  } & ActionEmailCallRequestWritable) | ({
    tool_call_type: 'sql_query';
  } & ActionSqlQueryCallRequestWritable) | ({
    tool_call_type: 'restapi_request';
  } & ActionRestCallRequestWritable) | ({
    tool_call_type: 'sftp_request';
  } & ActionSftpCallRequestWritable) | ({
    tool_call_type: 'microsoft_share_point_excel_request';
  } & ActionSharePointExcelCallRequestWritable) | ({
    tool_call_type: 'aws_lambda_request';
  } & ActionAwsLambdaCallRequestWritable) | ({
    tool_call_type: 'manual_upload';
  } & ActionManualUploadCallRequest) | ({
    tool_call_type: 'run_data_activation_client';
  } & ActionRunDataActivationClientCallRequestWritable);
  /**
   * Tool that executes this action. Required for every action type except data_activation, which refuses one: its client carries its own tool.
   */
  tool_id?: string | null;
  /**
   * Liquid template that determines when this action executes
   */
  trigger_template: string;
};
/**
 * DatalakeCloudStorageR2Request
 */
type DatalakeCloudStorageR2RequestWritable = CloudStorageR2RequestWritable & {
  cloud_storage_type: 'r2';
};
/**
 * DataActivationClientRESTCallRequest
 */
type DataActivationClientRestCallRequestWritable = RestCallRequestWritable & {
  tool_call_type: 'restapi_request';
};
/**
 * WorkflowAiAgentRequest
 *
 * Join entry linking an AI agent to a workflow at a specific execution position in the enrichment pipeline. Request
 */
type WorkflowAiAgentRequestWritable = {
  /**
   * AI agent ID
   */
  ai_agent_id: string;
  context_mapping_config: SimpleTemplateConfigRequest;
  /**
   * Execution order in the enrichment pipeline
   */
  position: number;
};
/**
 * AiAgentRequest
 *
 * AI Agent configuration — reusable chat-completion resource Request
 */
type AiAgentRequestWritable = {
  /**
   * Which lake the agent reads. `tokenized` means the agent's context is read from the tokenized copy, so it never sees a real identifier. It is enforced, not advisory: an agent set to `tokenized` in an environment with no tokenized lake fails its enrichment step rather than falling back to raw.
   */
  data_access: 'raw' | 'tokenized';
  /**
   * Agent description
   */
  description?: string | null;
  /**
   * Whether the agent is enabled
   */
  enabled: boolean;
  /**
   * AI Agent ID
   */
  id?: string;
  /**
   * JSON Schema describing the agent's input contract — validated by the runner against caller context on every invocation.
   */
  input_schema: {
    [key: string]: unknown;
  };
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * JSON Schema for LLM response format
   */
  llm_response_schema: {
    [key: string]: unknown;
  } | null;
  /**
   * Maximum tokens for LLM response
   */
  max_tokens: number;
  /**
   * LLM model identifier
   */
  model: string;
  /**
   * Agent name
   */
  name: string;
  prompt_config: SimpleTemplateConfigRequest;
  /**
   * URL-friendly slug
   */
  slug?: string;
  /**
   * Sampling temperature (0.0–2.0)
   */
  temperature: number;
  /**
   * Tool ID
   */
  tool_id: string;
  /**
   * Last update timestamp
   */
  updated_at?: string;
};
/**
 * EmailRequest
 *
 * Email tool configuration — SES, Mailgun, SendGrid, SMTP, or mock (dev mailbox) provider plus base Liquid templates. Request
 */
type EmailRequestWritable = {
  /**
   * AWS access key ID (SES)
   */
  access_key_id?: string;
  /**
   * API key (Mailgun/SendGrid)
   */
  api_key?: string;
  /**
   * Sending domain (Mailgun)
   */
  domain?: string;
  /**
   * Custom provider endpoint; leave blank for the real provider. For SES, the whole request URL (e.g., http://localhost:4566 for MiniStack); blank means https://email.<region>.amazonaws.com. For Mailgun, the API base URL (e.g., https://api.eu.mailgun.net/v3 for EU domains, or a WireMock endpoint for integration tests)
   */
  endpoint_url?: string | null;
  /**
   * Default sender email address
   */
  from_email: string;
  /**
   * Default sender display name
   */
  from_name?: string | null;
  /**
   * ID of the primary Email tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * Email provider (mock = in-process dev mailbox, no credentials)
   */
  provider: 'ses' | 'mailgun' | 'sendgrid' | 'smtp' | 'mock';
  /**
   * AWS region (SES)
   */
  region?: string;
  /**
   * Default reply-to address
   */
  reply_to?: string | null;
  /**
   * AWS secret access key (SES)
   */
  secret_access_key?: string;
  /**
   * SMTP server hostname
   */
  smtp_host?: string;
  /**
   * SMTP password
   */
  smtp_password?: string;
  /**
   * SMTP server port
   */
  smtp_port?: number;
  /**
   * SMTP username
   */
  smtp_username?: string;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type?: 'primary' | 'variant';
};
/**
 * S3CloudStorageR2Request
 */
type S3CloudStorageR2RequestWritable = CloudStorageR2RequestWritable & {
  storage_config_type: 'r2';
};
/**
 * ToolTwilioRequest
 */
type ToolTwilioRequestWritable = TwilioRequestWritable & {
  tool_body_type: 'twilio';
};
/**
 * ToolSQLDatabaseRequest
 */
type ToolSqlDatabaseRequestWritable = SqlDatabaseRequestWritable & {
  tool_body_type: 'sql_database';
};
/**
 * ActionRESTCallRequest
 */
type ActionRestCallRequestWritable = RestCallRequestWritable & {
  tool_call_type: 'restapi_request';
};
/**
 * GenericTableRequest
 *
 * Generic Table — custom or system dataset table with column definitions. Request
 */
type GenericTableRequestWritable = {
  /**
   * Table column definitions
   */
  columns?: Array<GenericTableColumnRequest>;
  /**
   * Table description
   */
  description?: string;
  /**
   * User-friendly table title
   */
  title?: string;
};
/**
 * ToolSFTPRequest
 */
type ToolSftpRequestWritable = SftpRequestWritable & {
  tool_body_type: 'sftp';
};
/**
 * ActionSQLQueryCallRequest
 */
type ActionSqlQueryCallRequestWritable = SqlQueryCallRequestWritable & {
  tool_call_type: 'sql_query';
};
/**
 * ActionSFTPCallRequest
 */
type ActionSftpCallRequestWritable = SftpCallRequest & {
  tool_call_type: 'sftp_request';
};
/**
 * AWSLambdaCallRequest
 *
 * AWS Lambda invocation descriptor — Liquid-templated payload + timeout. Request
 */
type AwsLambdaCallRequestWritable = {
  payload: SimpleTemplateConfigRequest;
  /**
   * Lambda invocation timeout in milliseconds (max 900000 = 15 minutes)
   */
  timeout_ms?: number;
};
/**
 * ToolCloudWatchLogGroupRequest
 */
type ToolCloudWatchLogGroupRequestWritable = CloudWatchLogGroupRequestWritable & {
  tool_body_type: 'cloud_watch_log_group';
};
/**
 * ManualToolInvocationSQLQueryCallRequest
 */
type ManualToolInvocationSqlQueryCallRequestWritable = SqlQueryCallRequestWritable & {
  tool_call_type: 'sql_query';
};
/**
 * DataActivationClientAWSLambdaCallRequest
 */
type DataActivationClientAwsLambdaCallRequestWritable = AwsLambdaCallRequestWritable & {
  tool_call_type: 'aws_lambda_request';
};
/**
 * DataActivationClientS3CallRequest
 */
type DataActivationClientS3CallRequestWritable = S3CallRequest & {
  tool_call_type: 's3_request';
};
/**
 * S3CloudStorageAwsRequest
 */
type S3CloudStorageAwsRequestWritable = CloudStorageAwsRequestWritable & {
  storage_config_type: 'aws';
};
/**
 * CloudStorageR2Request
 *
 * Cloudflare R2 cloud storage configuration — S3-compatible with auto region and account-scoped endpoints. Request
 */
type CloudStorageR2RequestWritable = {
  /**
   * R2 access key ID
   */
  access_key_id: string;
  /**
   * Base path prefix for objects within the bucket
   */
  base_path?: string;
  /**
   * R2 bucket name
   */
  bucket: string;
  /**
   * Account-scoped R2 endpoint URL, e.g. https://<account-id>.r2.cloudflarestorage.com
   */
  endpoint: string;
  /**
   * R2 region (defaults to "auto")
   */
  region?: string;
  /**
   * R2 secret access key
   */
  secret_access_key: string;
};
/**
 * SharePointRequest
 *
 * Microsoft SharePoint integration via the Microsoft Graph API. Supports sites, document libraries, and lists with client-credential or managed-identity auth. Request
 */
type SharePointRequestWritable = {
  /**
   * Microsoft Graph authentication method
   */
  auth_method: 'client_credentials' | 'managed_identity';
  /**
   * Microsoft tenant ID (GUID)
   */
  azure_tenant_id: string;
  base_path?: ComplexTemplateConfigRequest;
  /**
   * Azure AD application/client ID (used when auth_method is client_credentials)
   */
  client_id?: string | null;
  /**
   * Azure AD client secret (used when auth_method is client_credentials)
   */
  client_secret?: string | null;
  /**
   * Optional specific drive ID to access
   */
  drive_id?: string | null;
  /**
   * Optional path within the drive (e.g., Documents/Reports)
   */
  drive_path?: string | null;
  /**
   * Type of SharePoint resource to interact with
   */
  resource_type: 'site' | 'library' | 'list';
  /**
   * SharePoint site URL (e.g., https://contoso.sharepoint.com/sites/finance)
   */
  site_url?: string | null;
};
/**
 * ManualToolInvocationSMSCallRequest
 */
type ManualToolInvocationSmsCallRequestWritable = SmsCallRequestWritable & {
  tool_call_type: 'sms_request';
};
/**
 * ManualToolInvocationRequest
 *
 * A manual test invocation of a tool. The request body carries only `tool_call` (polymorphic on `__type__`); all other fields are server-populated and returned in the response. Request
 */
type ManualToolInvocationRequestWritable = {
  tool_call?: ({
    tool_call_type: 'sms_request';
  } & ManualToolInvocationSmsCallRequestWritable) | ({
    tool_call_type: 'mms_request';
  } & ManualToolInvocationMmsCallRequestWritable) | ({
    tool_call_type: 'email_request';
  } & ManualToolInvocationEmailCallRequestWritable) | ({
    tool_call_type: 'restapi_request';
  } & ManualToolInvocationRestCallRequestWritable) | ({
    tool_call_type: 'aws_lambda_request';
  } & ManualToolInvocationAwsLambdaCallRequestWritable) | ({
    tool_call_type: 'sql_query';
  } & ManualToolInvocationSqlQueryCallRequestWritable);
};
/**
 * SQLQueryCallRequest
 *
 * SQL query descriptor — Liquid-templated query body. Request
 */
type SqlQueryCallRequestWritable = {
  query: SimpleTemplateConfigRequest;
};
/**
 * CloudWatchLogGroupRequest
 *
 * AWS CloudWatch Logs authentication credential store. Referenced by ActionStatusUpdater for log-group polling. Request
 */
type CloudWatchLogGroupRequestWritable = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * IAM role ARN to assume in the customer's AWS account (used when auth_method is assume_role)
   */
  assume_role_arn?: string | null;
  /**
   * External ID for the STS AssumeRole call, unique per customer
   */
  assume_role_external_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role' | 'assume_role';
  base_filter_pattern?: ComplexTemplateConfigRequest;
  /**
   * Custom CloudWatch Logs endpoint URL (e.g., http://localhost:4566 for MiniStack)
   */
  endpoint_url?: string | null;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
  /**
   * AWS secret access key (used when auth_method is access_key)
   */
  secret_access_key?: string | null;
};
/**
 * SNSRequest
 *
 * AWS SNS tool configuration for sending SMS messages via the SNS Publish API. Request
 */
type SnsRequestWritable = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * IAM role ARN to assume in the customer's AWS account (used when auth_method is assume_role)
   */
  assume_role_arn?: string | null;
  /**
   * External ID for the STS AssumeRole call, unique per customer (auto-generated when auth_method is assume_role)
   */
  assume_role_external_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role' | 'assume_role';
  base_message?: ComplexTemplateConfigRequest;
  /**
   * Custom SNS endpoint URL (e.g., http://localhost:4566 for MiniStack); leave blank for real AWS
   */
  endpoint_url?: string | null;
  /**
   * Origination phone number in E.164 format (e.g., +15551234567)
   */
  phone_number: string;
  /**
   * ID of the primary SNS tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
  /**
   * AWS secret access key (used when auth_method is access_key)
   */
  secret_access_key?: string | null;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type?: 'primary' | 'variant';
};
/**
 * ToolEmailRequest
 */
type ToolEmailRequestWritable = EmailRequestWritable & {
  tool_body_type: 'email';
};
/**
 * ManualToolInvocationMMSCallRequest
 */
type ManualToolInvocationMmsCallRequestWritable = MmsCallRequestWritable & {
  tool_call_type: 'mms_request';
};
/**
 * ActionStatusUpdaterCloudWatchQueryRequest
 */
type ActionStatusUpdaterCloudWatchQueryRequestWritable = CloudWatchQueryRequest & {
  updater_body_type: 'cloud_watch_request';
};
/**
 * ActionStatusUpdaterRESTCallRequest
 */
type ActionStatusUpdaterRestCallRequestWritable = RestCallRequestWritable & {
  updater_body_type: 'restapi_request';
};
/**
 * SQSRequest
 *
 * AWS SQS (Simple Queue Service) tool configuration for sending and receiving queue messages. Request
 */
type SqsRequestWritable = {
  /**
   * AWS access key ID (used when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method: 'access_key' | 'iam_role';
  base_message?: ComplexTemplateConfigRequest;
  /**
   * Whether the queue is a FIFO queue (URL must end with .fifo)
   */
  fifo?: boolean;
  /**
   * Optional human-readable queue name for identification
   */
  queue_name?: string | null;
  /**
   * Full SQS queue URL
   */
  queue_url: string;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
  /**
   * AWS secret access key (used when auth_method is access_key)
   */
  secret_access_key?: string | null;
};
/**
 * ToolAWSLambdaRequest
 */
type ToolAwsLambdaRequestWritable = AwsLambdaRequestWritable & {
  tool_body_type: 'aws_lambda';
};
/**
 * ActionSharePointExcelCallRequest
 */
type ActionSharePointExcelCallRequestWritable = SharePointExcelCallRequest & {
  tool_call_type: 'microsoft_share_point_excel_request';
};
/**
 * InteroperabilityContractRequest
 *
 * Declarative execution spec binding a `(datalake, resource_type)` pair to the ingestion pipeline: filter → transform → mdm_input → resolve → upsert. Request
 */
type InteroperabilityContractRequestWritable = {
  /**
   * Optional description
   */
  description?: string | null;
  /**
   * Liquid filter body. Renders to empty/whitespace → row passes; any non-empty trimmed render → row is skipped (rendered string is the skip reason). Nil/empty body = no filter.
   */
  filter_template?: string | null;
  /**
   * Generic table ID (required when resource_type == "generic_table")
   */
  generic_table_id?: string | null;
  /**
   * Contract ID
   */
  id?: string;
  /**
   * Creation timestamp
   */
  inserted_at?: string;
  /**
   * AI agents to attach to this contract (request)
   */
  interoperability_contract_ai_agents?: Array<InteroperabilityContractAiAgentRequestWritable>;
  mdm_input_config?: SimpleTemplateConfigRequest;
  /**
   * Human-readable contract name
   */
  name: string;
  /**
   * Dataset this contract targets (e.g. "legal_entity", "beneficial_owner", "generic_table")
   */
  resource_type: string;
  /**
   * URL-friendly slug (derived from name on insert; immutable)
   */
  slug?: string;
  template_config: SimpleTemplateConfigRequest;
  /**
   * Template type (synced from template_config.type)
   */
  type?: 'system' | 'custom' | 'identity' | 'null';
  /**
   * Last update timestamp
   */
  updated_at?: string;
};
/**
 * RESTCallRequest
 *
 * REST API call descriptor — HTTP method, path, body, params, pagination context template, and events extraction template. Reused across ActionStatusUpdater polling, data activation clients, tool protocols, OAuth token fetching, and chat completion; events_template is the status-poll extraction concern and is required only there. Request
 */
type RestCallRequestWritable = {
  body?: SimpleTemplateConfigRequest;
  events_template?: SimpleTemplateConfigRequest;
  /**
   * HTTP method
   */
  method: 'head' | 'get' | 'put' | 'post' | 'delete' | 'patch';
  pagination_context_template: SimpleTemplateConfigRequest;
  params?: SimpleTemplateConfigRequest;
  path: SimpleTemplateConfigRequest;
};
/**
 * ContextDatasetRequest
 *
 * Context dataset for a workflow — declares which records the context builder should load (and under what filter) before the enrichment and decision stages. Request
 */
type ContextDatasetRequestWritable = {
  /**
   * Dataset type — either a standard industry resource (e.g. "patient", "appointment") or "generic_table" to reference a custom table
   */
  dataset_type: string;
  /**
   * Required when `dataset_type == "generic_table"`
   */
  generic_table_id?: string | null;
  /**
   * Context dataset ID — echo it back on update to modify the existing dataset rather than replace it
   */
  id?: string;
  /**
   * Max records to load for this context dataset
   */
  limit?: number | null;
  /**
   * Ordering within the context-builder pipeline
   */
  position?: number;
  /**
   * Liquid-templated SQL WHERE clause for filtering records at runtime. The context builder appends the legal entity FK automatically.
   */
  where_clause?: string | null;
};
/**
 * RESTAPIRequest
 *
 * REST API tool configuration with OpenAPI-compliant authentication (API key, basic, bearer, OAuth2, OIDC) plus base Liquid templates. Request
 */
type RestapiRequestWritable = {
  /**
   * API key value (used when auth_method is api_key)
   */
  api_key?: string | null;
  /**
   * Where to send the API key (header or query parameter)
   */
  api_key_location?: 'header' | 'query';
  /**
   * Header or query-parameter name for the API key
   */
  api_key_name?: string | null;
  /**
   * Authentication method
   */
  auth_method: 'none' | 'api_key' | 'basic' | 'bearer' | 'oauth2' | 'oidc';
  base_body?: SimpleTemplateConfigRequest;
  base_headers?: SimpleTemplateConfigRequest;
  base_path?: SimpleTemplateConfigRequest;
  base_query?: SimpleTemplateConfigRequest;
  /**
   * Base URL (https) of the REST API endpoint
   */
  base_url: string;
  /**
   * Static bearer token (used when auth_method is bearer)
   */
  bearer_token?: string | null;
  /**
   * OAuth2 client ID
   */
  oauth2_client_id?: string | null;
  /**
   * OAuth2 client secret
   */
  oauth2_client_secret?: string | null;
  /**
   * OAuth2 grant type
   */
  oauth2_grant_type?: 'client_credentials' | 'authorization_code';
  /**
   * OAuth2 refresh token for authorization_code grant. Obtained from the provider's OAuth consent flow and pasted here. The platform auto-rotates it.
   */
  oauth2_refresh_token?: string | null;
  /**
   * OAuth2 scope(s)
   */
  oauth2_scope?: string | null;
  /**
   * OAuth2 token cache TTL in seconds
   */
  oauth2_token_ttl?: number | null;
  /**
   * OAuth2 token endpoint URL
   */
  oauth2_token_url?: string | null;
  /**
   * OIDC client ID
   */
  oidc_client_id?: string | null;
  /**
   * OIDC client secret
   */
  oidc_client_secret?: string | null;
  /**
   * OIDC issuer URL for discovery
   */
  oidc_issuer_url?: string | null;
  /**
   * OIDC token cache TTL in seconds
   */
  oidc_token_ttl?: number | null;
  /**
   * Password (used when auth_method is basic)
   */
  password?: string | null;
  /**
   * Request content type
   */
  request_type: 'json' | 'xml' | 'form_urlencoded' | 'multipart_form';
  /**
   * Response content type
   */
  response_type: 'json' | 'xml' | 'text' | 'binary';
  /**
   * Request timeout in milliseconds (max 300000)
   */
  timeout_ms: number;
  /**
   * Username (used when auth_method is basic)
   */
  username?: string | null;
};
/**
 * DatalakeCloudStorageCustomRequest
 */
type DatalakeCloudStorageCustomRequestWritable = CloudStorageCustomRequestWritable & {
  cloud_storage_type: 'custom';
};
/**
 * CloudStorageAwsRequest
 *
 * AWS S3 cloud storage configuration supporting access key and IAM role authentication. Request
 */
type CloudStorageAwsRequestWritable = {
  /**
   * AWS access key ID (required when auth_method is access_key)
   */
  access_key_id?: string | null;
  /**
   * AWS authentication method
   */
  auth_method?: 'access_key' | 'iam_role';
  /**
   * Base path prefix for objects within the bucket
   */
  base_path?: string;
  /**
   * S3 bucket name
   */
  bucket: string;
  /**
   * Custom S3 endpoint URL (optional, defaults to AWS)
   */
  endpoint?: string | null;
  /**
   * AWS region (e.g., us-east-1)
   */
  region: string;
  /**
   * AWS secret access key (required when auth_method is access_key)
   */
  secret_access_key?: string | null;
};
/**
 * SFTPRequest
 *
 * SFTP (SSH File Transfer Protocol) server connection configuration with password or SSH key auth. Request
 */
type SftpRequestWritable = {
  /**
   * SFTP authentication method
   */
  auth_method: 'password' | 'ssh_key';
  /**
   * Base directory path on the SFTP server
   */
  base_path: string;
  base_path_template?: ComplexTemplateConfigRequest;
  /**
   * SFTP server hostname or IP address
   */
  host: string;
  /**
   * SFTP password (used when auth_method is password)
   */
  password?: string | null;
  /**
   * SFTP port
   */
  port: number;
  /**
   * SSH private key content (used when auth_method is ssh_key)
   */
  private_key?: string | null;
  /**
   * Optional passphrase for encrypted SSH private key
   */
  private_key_passphrase?: string | null;
  /**
   * SFTP username
   */
  user_name: string;
};
/**
 * ActionRunDataActivationClientCallRequest
 */
type ActionRunDataActivationClientCallRequestWritable = RunDataActivationClientCallRequest & {
  tool_call_type: 'run_data_activation_client';
};
/**
 * CloudStorageCustomRequest
 *
 * Custom S3-compatible cloud storage configuration — for MinIO, DigitalOcean Spaces, Backblaze B2, and other S3-compatible services. Requires a custom endpoint URL. Request
 */
type CloudStorageCustomRequestWritable = {
  /**
   * Access key ID
   */
  access_key_id: string;
  /**
   * Base path prefix for objects within the bucket
   */
  base_path?: string;
  /**
   * Bucket name
   */
  bucket: string;
  /**
   * Custom S3-compatible endpoint URL (required)
   */
  endpoint: string;
  /**
   * Storage region (e.g., us-east-1)
   */
  region: string;
  /**
   * Secret access key
   */
  secret_access_key: string;
};
/**
 * DataActivationClientRequest
 *
 * Data Activation Client — binds a (datalake, data_source, tool) triple with a polymorphic `tool_call` config describing how to fetch data from the external system, plus optional cron schedule, row-level filter, downstream triggers, and interop contracts for row-level transformation. Request
 */
type DataActivationClientRequestWritable = {
  /**
   * Cron expressions (Crontab syntax, array). Examples: ["0 *6 * * *"] for every 6 hours. Omit for on-demand clients.
   */
  cron_expressions?: Array<string>;
  /**
   * Owning data source ID
   */
  data_source_id: string;
  /**
   * DAC description
   */
  description?: string | null;
  /**
   * IDs of downstream DACs triggered after this one completes
   */
  downstream_connection_ids?: Array<string>;
  filter_config?: SimpleTemplateConfigRequest;
  /**
   * IDs of interoperability contracts used to transform each fetched row
   */
  interoperability_contract_ids?: Array<string>;
  /**
   * DAC name
   */
  name: string;
  /**
   * Optional row-level Liquid pre-filter. Renders to empty/whitespace → row passes; any non-empty trimmed render → row is skipped (rendered string is the skip reason). Nil/empty body = no filter. Same semantics as InteroperabilityContract.filter_template.
   */
  row_filter?: string | null;
  rows_from_file_template?: SimpleTemplateConfigRequest | null;
  tool_call: ({
    tool_call_type: 'restapi_request';
  } & DataActivationClientRestCallRequestWritable) | ({
    tool_call_type: 'sql_query';
  } & DataActivationClientSqlQueryCallRequestWritable) | ({
    tool_call_type: 'sftp_request';
  } & DataActivationClientSftpCallRequestWritable) | ({
    tool_call_type: 'microsoft_share_point_excel_request';
  } & DataActivationClientSharePointExcelCallRequestWritable) | ({
    tool_call_type: 'aws_lambda_request';
  } & DataActivationClientAwsLambdaCallRequestWritable) | ({
    tool_call_type: 'manual_upload';
  } & DataActivationClientManualUploadCallRequest) | ({
    tool_call_type: 's3_request';
  } & DataActivationClientS3CallRequestWritable);
  /**
   * Owning tool ID
   */
  tool_id: string;
};
/**
 * ActionAWSLambdaCallRequest
 */
type ActionAwsLambdaCallRequestWritable = AwsLambdaCallRequestWritable & {
  tool_call_type: 'aws_lambda_request';
};
/**
 * TwilioRequest
 *
 * Twilio tool configuration for sending SMS and MMS via the Programmable Messaging API. A primary holds the account credential; a variant names its primary and carries only its own sender identity. Request
 */
type TwilioRequestWritable = {
  /**
   * Twilio Account SID (required on a primary; supplied by the primary on a variant)
   */
  account_sid?: string | null;
  /**
   * Twilio API Key Secret (required when auth_method is api_key)
   */
  api_key_secret?: string | null;
  /**
   * Twilio API Key SID (required when auth_method is api_key)
   */
  api_key_sid?: string | null;
  /**
   * How this primary authenticates to Twilio. Defaults to auth_token.
   */
  auth_method?: 'auth_token' | 'api_key';
  /**
   * Twilio Auth Token (required on a primary; supplied by the primary on a variant)
   */
  auth_token?: string | null;
  base_message?: ComplexTemplateConfigRequest;
  /**
   * Custom Twilio API base URL (e.g., http://localhost:8080 for WireMock); leave blank for https://api.twilio.com
   */
  base_url?: string | null;
  /**
   * Origination phone number in E.164 format (e.g., +15551234567)
   */
  from_number?: string | null;
  /**
   * Twilio Messaging Service SID, used instead of a from_number
   */
  messaging_service_sid?: string | null;
  /**
   * ID of the primary Twilio tool supplying credentials; required when variant_type is variant
   */
  primary_tool_id?: string | null;
  /**
   * Request timeout in milliseconds (1–300000)
   */
  timeout_ms?: number | null;
  /**
   * Whether this tool holds the account credential (primary) or borrows another tool's (variant). Defaults to primary.
   */
  variant_type: 'primary' | 'variant';
};
/**
 * DataActivationClientSFTPCallRequest
 */
type DataActivationClientSftpCallRequestWritable = SftpCallRequest & {
  tool_call_type: 'sftp_request';
};
/**
 * RunManuallyRequest
 *
 * Optional polymorphic tool_call override for this run. When omitted or empty, the DAC's persisted tool_call is used.
 */
type RunManuallyRequestWritable = {
  /**
   * One-shot polymorphic tool_call override. Same `tool_call_type` discriminator and variants as DataActivationClientRequest.tool_call.
   */
  tool_call?: ({
    tool_call_type: 'DataActivationClientRESTCallRequestWritable';
  } & DataActivationClientRestCallRequestWritable) | ({
    tool_call_type: 'DataActivationClientSQLQueryCallRequestWritable';
  } & DataActivationClientSqlQueryCallRequestWritable) | ({
    tool_call_type: 'DataActivationClientSFTPCallRequestWritable';
  } & DataActivationClientSftpCallRequestWritable) | ({
    tool_call_type: 'DataActivationClientSharePointExcelCallRequestWritable';
  } & DataActivationClientSharePointExcelCallRequestWritable) | ({
    tool_call_type: 'DataActivationClientAWSLambdaCallRequestWritable';
  } & DataActivationClientAwsLambdaCallRequestWritable) | ({
    tool_call_type: 'DataActivationClientManualUploadCallRequest';
  } & DataActivationClientManualUploadCallRequest) | ({
    tool_call_type: 'DataActivationClientS3CallRequestWritable';
  } & DataActivationClientS3CallRequestWritable) | null;
};
/**
 * ToolEndUserMessagingRequest
 */
type ToolEndUserMessagingRequestWritable = EndUserMessagingRequestWritable & {
  tool_body_type: 'end_user_messaging';
};
/**
 * ManualToolInvocationEmailCallRequest
 */
type ManualToolInvocationEmailCallRequestWritable = EmailCallRequestWritable & {
  tool_call_type: 'email_request';
};
/**
 * DatalakeCloudStorageAwsRequest
 */
type DatalakeCloudStorageAwsRequestWritable = CloudStorageAwsRequestWritable & {
  cloud_storage_type: 'aws';
};
/**
 * ActionMMSCallRequest
 */
type ActionMmsCallRequestWritable = MmsCallRequestWritable & {
  tool_call_type: 'mms_request';
};
/**
 * ManualToolInvocationAWSLambdaCallRequest
 */
type ManualToolInvocationAwsLambdaCallRequestWritable = AwsLambdaCallRequestWritable & {
  tool_call_type: 'aws_lambda_request';
};
/**
 * ToolS3Request
 */
type ToolS3RequestWritable = S3RequestWritable & {
  tool_body_type: 's3';
};
/**
 * ManualToolInvocationRESTCallRequest
 */
type ManualToolInvocationRestCallRequestWritable = RestCallRequestWritable & {
  tool_call_type: 'restapi_request';
};
/**
 * SignUpRequest
 *
 * Register a new user account. Mirrors the `/auth/register` LiveView form
 * submission shape. The created user is **unconfirmed** — caller must
 * confirm separately (e.g. via the email confirmation flow, or via
 * `PUT /api/v1/admin/users/:id/confirm` for tests) before signing in.
 *
 * No authentication is required.
 * Request
 */
type SignUpRequestWritable = {
  /**
   * User email
   */
  email: string;
  /**
   * First name
   */
  first_name: string | null;
  /**
   * Last name
   */
  last_name: string | null;
  /**
   * Password (8–72 characters; mirrors the `/auth/register` LiveView form)
   */
  password: string;
};
/**
 * DataActivationClientSQLQueryCallRequest
 */
type DataActivationClientSqlQueryCallRequestWritable = SqlQueryCallRequestWritable & {
  tool_call_type: 'sql_query';
};
/**
 * ToolSNSRequest
 */
type ToolSnsRequestWritable = SnsRequestWritable & {
  tool_body_type: 'sns';
};
/**
 * ActionStatusUpdaterRequest
 *
 * Action Status Updater — automated polling for delivery status updates. Request
 */
type ActionStatusUpdaterRequestWritable = {
  action_log_config: SimpleTemplateConfigRequest;
  /**
   * Cron schedule expression (e.g. "*30 * * * *")
   */
  cron_expression: string;
  /**
   * Datalake ID
   */
  datalake_id: string;
  /**
   * JSON Schema the rendered events_template output is validated against on every poll (required for restapi updaters). FLOOR: it must describe an array whose items are objects listing "external_id" in "required" — every event has to name the message it reconciles, so the events_template maps the provider's own id (messageId / id / sid) into external_id. Add whatever else your provider guarantees on top; the platform only enforces the floor.
   */
  events_output_schema?: {
    [key: string]: unknown;
  } | null;
  message_config: SimpleTemplateConfigRequest;
  /**
   * Updater name
   */
  name: string;
  /**
   * JSON Schema the rendered pagination_context_template output is validated against on every poll (required for restapi updaters). FLOOR: it must describe an object listing "has_next" in "required" — that key is what ends the page loop. Add the provider's cursor keys on top; the platform only enforces the floor.
   */
  pagination_context_output_schema?: {
    [key: string]: unknown;
  } | null;
  /**
   * IDs of sender tools whose messages this updater monitors
   */
  sender_tool_ids?: Array<string> | null;
  /**
   * Whether this updater may poll. The server sets cycle_detected when a run re-reads events it has already handled, and every later job then fails without calling the provider. Set it back to active to resume polling — nothing else clears it.
   */
  status?: 'active' | 'cycle_detected';
  updater_body: ({
    updater_body_type: 'cloud_watch_request';
  } & ActionStatusUpdaterCloudWatchQueryRequestWritable) | ({
    updater_body_type: 'restapi_request';
  } & ActionStatusUpdaterRestCallRequestWritable);
  /**
   * Tool providing auth credentials for polling
   */
  updater_tool_id: string;
  /**
   * Updater type — determines the updater_body shape
   */
  updater_type: 'cloud_watch' | 'restapi';
};
/**
 * S3Request
 *
 * S3-compatible storage tool configuration with a nested polymorphic provider config (AWS or R2). Request
 */
type S3RequestWritable = {
  base_prefix?: ComplexTemplateConfigRequest;
  config: ({
    storage_config_type: 'aws';
  } & S3CloudStorageAwsRequestWritable) | ({
    storage_config_type: 'r2';
  } & S3CloudStorageR2RequestWritable);
};
/**
 * SQLDatabaseRequest
 *
 * SQL database connection configuration (PostgreSQL, MySQL, MSSQL, SQLite, Snowflake). Request
 */
type SqlDatabaseRequestWritable = {
  base_query?: ComplexTemplateConfigRequest;
  /**
   * Database host (hostname or IP address)
   */
  db_host: string;
  /**
   * Database name
   */
  db_name: string;
  /**
   * SQL database engine
   */
  db_type: 'postgres' | 'mysql' | 'mssql' | 'sqlite' | 'snowflake';
  /**
   * Database password
   */
  password: string;
  /**
   * Ecto connection pool size
   */
  pool_size?: number | null;
  /**
   * Database port (defaults based on db_type: postgres=5432, mysql=3306, mssql=1433)
   */
  port?: number | null;
  /**
   * Enable SSL connection
   */
  ssl?: boolean | null;
  /**
   * SSL mode (e.g., 'require', 'verify-full')
   */
  ssl_mode?: string | null;
  /**
   * Database username
   */
  user_name: string;
};
/**
 * SMSCallRequest
 *
 * SMS tool-call config — Liquid-templated recipient and body, transactional/promotional category, and the prefix its links go out on. Request
 */
type SmsCallRequestWritable = {
  body: SimpleTemplateConfigRequest;
  /**
   * Address of the host that serves this action's links. Every URL in the body goes out as <link_prefix>/<token>. An absolute http or https URL, path allowed, with no query, fragment or trailing slash.
   */
  link_prefix: string;
  /**
   * How many days each link resolves after the send
   */
  link_validity_days?: number;
  /**
   * SMS category — transactional vs promotional
   */
  sms_type?: 'transactional' | 'promotional';
  to: SimpleTemplateConfigRequest;
};
type PlatformApiTenantControllerIndexData = {
  body?: never;
  path?: never;
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants';
};
type PlatformApiGenericTableControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/generic-tables';
};
type PlatformApiInteroperabilityContractControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/interoperability-contracts';
};
type PlatformApiDatalakeControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
  };
  query?: {
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes';
};
type PlatformApiAdvancedMigrationControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/advanced-migrations';
};
type PlatformApiDataActivationClientControllerBatchesIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
    /**
     * Data Activation Client slug
     */
    slug: string;
  };
  query?: {
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/batches';
};
type PlatformApiAiAgentControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/ai-agents';
};
type PlatformApiWorkflowRunControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/workflow-runs';
};
type PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
    /**
     * Workflow slug
     */
    workflow_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{workflow_slug}/workflow-logs';
};
type PlatformApiDataSourceControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-sources';
};
type PlatformApiActionStatusUpdaterControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/action-status-updaters';
};
type PlatformApiAgenticWorkflowControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows';
};
type PlatformApiDataActivationClientControllerLogsIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
    /**
     * Data Activation Client slug
     */
    slug: string;
  };
  query?: {
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients/{slug}/logs';
};
type PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
    /**
     * Workflow slug
     */
    workflow_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/agentic-workflows/{workflow_slug}/batch-logs';
};
type PlatformApiDatalakeControllerMetadataData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/metadata';
};
type PlatformApiDataActivationClientControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/data-activation-clients';
};
type PlatformApiToolControllerIndexData = {
  body?: never;
  path: {
    /**
     * Tenant slug
     */
    tenant_slug: string;
    /**
     * Datalake slug
     */
    datalake_slug: string;
  };
  query?: {
    /**
     * Page number (1-indexed). Defaults to 1 when omitted.
     */
    page?: number;
    /**
     * Items per page (1-100). Defaults to the resource's Flop default when omitted.
     */
    page_size?: number;
    /**
     * Fields to sort by, in order of precedence. Must appear in the resource schema's Flop `sortable:` list — unknown fields return 422.
     */
    order_by?: Array<string>;
    /**
     * Sort direction(s), pair-wise with `order_by`. `asc` or `desc`. Defaults to `asc` per unpaired `order_by` entry.
     */
    order_directions?: Array<'asc' | 'desc'>;
    /**
     * Flop-native filter array. URL shape: `?filters[][field]=status&filters[][op]=%3D%3D&filters[][value]=pending` (empty brackets — consecutive `[]` entries group into one filter object per element; indexed brackets parse as a map and fail the array cast with 422). `op` is the symbol, percent-encoded — `%3D%3D` for `==`, `%3E%3D` for `>=` — not a word like `equal`; anything outside the enum above is a 422 before the request reaches Flop. Omit `op` entirely for equality. Unknown fields return 422 via Flop validation at the context layer.
     */
    filters?: Array<{
      /**
       * Filterable field name (must be in the resource's `filterable:`)
       */
      field: string;
      /**
       * Comparison operator. Defaults to `==` when omitted.
       */
      op?: '==' | '!=' | '<' | '<=' | '>' | '>=' | 'empty' | 'not_empty' | 'like' | 'ilike' | 'like_and' | 'like_or' | 'ilike_and' | 'ilike_or' | 'in' | 'not_in' | 'contains' | 'not_contains';
      /**
       * Filter value — shape depends on `field` and `op`.
       */
      value: unknown;
    }>;
  };
  url: '/api/v1/tenants/{tenant_slug}/datalakes/{datalake_slug}/tools';
};
//#endregion
//#region src/generated/core/auth.gen.d.ts
type AuthToken = string | undefined;
interface Auth {
  /**
   * Which part of the request do we use to send the auth?
   *
   * @default 'header'
   */
  in?: 'header' | 'query' | 'cookie';
  /**
   * Header or query parameter name.
   *
   * @default 'Authorization'
   */
  name?: string;
  scheme?: 'basic' | 'bearer';
  type: 'apiKey' | 'http';
}
//#endregion
//#region src/generated/core/pathSerializer.gen.d.ts
interface SerializerOptions<T> {
  /**
   * @default true
   */
  explode: boolean;
  style: T;
}
type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
type ObjectStyle = 'form' | 'deepObject';
//#endregion
//#region src/generated/core/bodySerializer.gen.d.ts
type QuerySerializer = (query: Record<string, unknown>) => string;
type BodySerializer = (body: unknown) => unknown;
type QuerySerializerOptionsObject = {
  allowReserved?: boolean;
  array?: Partial<SerializerOptions<ArrayStyle>>;
  object?: Partial<SerializerOptions<ObjectStyle>>;
};
type QuerySerializerOptions = QuerySerializerOptionsObject & {
  /**
   * Per-parameter serialization overrides. When provided, these settings
   * override the global array/object settings for specific parameter names.
   */
  parameters?: Record<string, QuerySerializerOptionsObject>;
};
//#endregion
//#region src/generated/core/types.gen.d.ts
type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
type Client$1<RequestFn$1 = never, Config$2 = unknown, MethodFn$1 = never, BuildUrlFn$1 = never, SseFn$1 = never> = {
  /**
   * Returns the final request URL.
   */
  buildUrl: BuildUrlFn$1;
  getConfig: () => Config$2;
  request: RequestFn$1;
  setConfig: (config: Config$2) => Config$2;
} & { [K in HttpMethod]: MethodFn$1 } & ([SseFn$1] extends [never] ? {
  sse?: never;
} : {
  sse: { [K in HttpMethod]: SseFn$1 };
});
interface Config {
  /**
   * Auth token or a function returning auth token. The resolved value will be
   * added to the request payload as defined by its `security` array.
   */
  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
  /**
   * A function for serializing request body parameter. By default,
   * {@link JSON.stringify()} will be used.
   */
  bodySerializer?: BodySerializer | null;
  /**
   * An object containing any HTTP headers that you want to pre-populate your
   * `Headers` object with.
   *
   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
   */
  headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
  /**
   * The request method.
   *
   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
   */
  method?: Uppercase<HttpMethod>;
  /**
   * A function for serializing request query parameters. By default, arrays
   * will be exploded in form style, objects will be exploded in deepObject
   * style, and reserved characters are percent-encoded.
   *
   * This method will have no effect if the native `paramsSerializer()` Axios
   * API function is used.
   *
   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
   */
  querySerializer?: QuerySerializer | QuerySerializerOptions;
  /**
   * A function validating request data. This is useful if you want to ensure
   * the request conforms to the desired shape, so it can be safely sent to
   * the server.
   */
  requestValidator?: (data: unknown) => Promise<unknown>;
  /**
   * A function transforming response data before it's returned. This is useful
   * for post-processing data, e.g., converting ISO strings into Date objects.
   */
  responseTransformer?: (data: unknown) => Promise<unknown>;
  /**
   * A function validating response data. This is useful if you want to ensure
   * the response conforms to the desired shape, so it can be safely passed to
   * the transformers and returned to the user.
   */
  responseValidator?: (data: unknown) => Promise<unknown>;
}
//#endregion
//#region src/generated/core/serverSentEvents.gen.d.ts
type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config, 'method' | 'responseTransformer' | 'responseValidator'> & {
  /**
   * Fetch API implementation. You can use this option to provide a custom
   * fetch instance.
   *
   * @default globalThis.fetch
   */
  fetch?: typeof fetch;
  /**
   * Implementing clients can call request interceptors inside this hook.
   */
  onRequest?: (url: string, init: RequestInit) => Promise<Request>;
  /**
   * Callback invoked when a network or parsing error occurs during streaming.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @param error The error that occurred.
   */
  onSseError?: (error: unknown) => void;
  /**
   * Callback invoked when an event is streamed from the server.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @param event Event streamed from the server.
   * @returns Nothing (void).
   */
  onSseEvent?: (event: StreamEvent<TData>) => void;
  serializedBody?: RequestInit['body'];
  /**
   * Default retry delay in milliseconds.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @default 3000
   */
  sseDefaultRetryDelay?: number;
  /**
   * Maximum number of retry attempts before giving up.
   */
  sseMaxRetryAttempts?: number;
  /**
   * Maximum retry delay in milliseconds.
   *
   * Applies only when exponential backoff is used.
   *
   * This option applies only if the endpoint returns a stream of events.
   *
   * @default 30000
   */
  sseMaxRetryDelay?: number;
  /**
   * Optional sleep function for retry backoff.
   *
   * Defaults to using `setTimeout`.
   */
  sseSleepFn?: (ms: number) => Promise<void>;
  url: string;
};
interface StreamEvent<TData = unknown> {
  data: TData;
  event?: string;
  id?: string;
  retry?: number;
}
type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
  stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
};
//#endregion
//#region src/generated/client/utils.gen.d.ts
type ErrInterceptor<Err, Res, Req, Options$1> = (error: Err, response: Res, request: Req, options: Options$1) => Err | Promise<Err>;
type ReqInterceptor<Req, Options$1> = (request: Req, options: Options$1) => Req | Promise<Req>;
type ResInterceptor<Res, Req, Options$1> = (response: Res, request: Req, options: Options$1) => Res | Promise<Res>;
declare class Interceptors<Interceptor> {
  fns: Array<Interceptor | null>;
  clear(): void;
  eject(id: number | Interceptor): void;
  exists(id: number | Interceptor): boolean;
  getInterceptorIndex(id: number | Interceptor): number;
  update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
  use(fn: Interceptor): number;
}
interface Middleware<Req, Res, Err, Options$1> {
  error: Interceptors<ErrInterceptor<Err, Res, Req, Options$1>>;
  request: Interceptors<ReqInterceptor<Req, Options$1>>;
  response: Interceptors<ResInterceptor<Res, Req, Options$1>>;
}
//#endregion
//#region src/generated/client/types.gen.d.ts
type ResponseStyle = 'data' | 'fields';
interface Config$1<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config {
  /**
   * Base URL for all requests made by this client.
   */
  baseUrl?: T['baseUrl'];
  /**
   * Fetch API implementation. You can use this option to provide a custom
   * fetch instance.
   *
   * @default globalThis.fetch
   */
  fetch?: typeof fetch;
  /**
   * Please don't use the Fetch client for Next.js applications. The `next`
   * options won't have any effect.
   *
   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
   */
  next?: never;
  /**
   * Return the response data parsed in a specified format. By default, `auto`
   * will infer the appropriate method from the `Content-Type` response header.
   * You can override this behavior with any of the {@link Body} methods.
   * Select `stream` if you don't want to parse response data at all.
   *
   * @default 'auto'
   */
  parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
  /**
   * Should we return only data or multiple fields (data, error, response, etc.)?
   *
   * @default 'fields'
   */
  responseStyle?: ResponseStyle;
  /**
   * Throw an error instead of returning it in the response?
   *
   * @default false
   */
  throwOnError?: T['throwOnError'];
}
interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config$1<{
  responseStyle: TResponseStyle;
  throwOnError: ThrowOnError;
}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
  /**
   * Any body that you want to add to your request.
   *
   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
   */
  body?: unknown;
  path?: Record<string, unknown>;
  query?: Record<string, unknown>;
  /**
   * Security mechanism(s) to use for the request.
   */
  security?: ReadonlyArray<Auth>;
  url: Url;
}
interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
  serializedBody?: string;
}
type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
  request: Request;
  response: Response;
}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
  data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
  error: undefined;
} | {
  data: undefined;
  error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
}) & {
  request: Request;
  response: Response;
}>;
interface ClientOptions {
  baseUrl?: string;
  responseStyle?: ResponseStyle;
  throwOnError?: boolean;
}
type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
type BuildUrlFn = <TData extends {
  body?: unknown;
  path?: Record<string, unknown>;
  query?: Record<string, unknown>;
  url: string;
}>(options: TData & Options<TData>) => string;
type Client = Client$1<RequestFn, Config$1, MethodFn, BuildUrlFn, SseFn> & {
  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
};
interface TDataShape {
  body?: unknown;
  headers?: unknown;
  path?: unknown;
  query?: unknown;
  url: string;
}
type OmitKeys<T, K$1> = Pick<T, Exclude<keyof T, K$1>>;
type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
//#endregion
//#region src/client.d.ts
/**
 * Forward-compat alias for DataSource write paths.
 *
 * Hey-api emits `<Schema>RequestWritable` variants only when a schema
 * has at least one `writeOnly: true` field — otherwise the Writable
 * shape would be byte-identical to the bare Request type, so it skips
 * the duplicate. DataSource has no writeOnly fields today, so
 * `DataSourceRequestWritable` is not generated.
 *
 * Aliasing it here gives every write path a uniform `*Writable` import
 * name (Datalake / Tool / DataSource), matching the Elixir-test
 * convention of typing every Create/Update body explicitly. When a
 * writeOnly field is eventually added to DataSource, hey-api will emit
 * its own `DataSourceRequestWritable`; at that point this alias should
 * be deleted in favour of the generated one, and the TS compiler will
 * surface the structural change at every write call-site.
 */
type DataSourceRequestWritable = DataSourceRequest;
interface CreateGenericTableRequest {
  title: string;
  description?: string;
  columns: GenericTableColumnRequest[];
}
interface TemplateConfig {
  type: 'system' | 'custom';
  path?: string;
  body?: string;
}
interface CreateActionStatusUpdaterRequest {
  name: string;
  cron_expression: string;
  updater_type: 'cloud_watch' | 'restapi';
  updater_tool_id: string;
  datalake_id: string;
  sender_tool_ids?: string[] | null;
  message_config: TemplateConfig;
  action_log_config: TemplateConfig;
  events_output_schema?: Record<string, unknown> | null;
  pagination_context_output_schema?: Record<string, unknown> | null;
  updater_body: ActionStatusUpdaterCloudWatchQueryRequest | ActionStatusUpdaterRestCallRequest;
}
interface CreateAiAgentRequest {
  name: string;
  model: string;
  tool_id: string;
  data_access: 'raw' | 'tokenized';
  temperature: number;
  max_tokens: number;
  enabled: boolean;
  slug?: string;
  description?: string | null;
  input_schema?: Record<string, unknown> | null;
  llm_response_schema?: Record<string, unknown> | null;
  prompt_config?: Record<string, unknown> | null;
}
interface CreateSessionParams {
  baseUrl: string;
  email: string;
  password: string;
  /**
   * Publishable API key of the tenant named by `tenantSlug`, sent as
   * `X-API-Key`. Required — the server 401s without one and 403s a key
   * belonging to a different tenant. The key is stamped onto the resulting
   * session for lineage, and the same key must accompany every subsequent
   * request alongside the Bearer.
   */
  apiKey: string;
  /**
   * Tenant slug to sign in to. Required — `POST /sessions` is tenant login
   * only; the tenantless bootstrap login lives at
   * `POST /api/v1/admin/bootstrap-session` (`createBootstrapSession`, an
   * integration-test-only route absent from prod builds).
   */
  tenantSlug: string;
  /** Session duration in seconds. Default 86400 (24h). Max 2592000 (30d). */
  expiresIn?: number;
}
interface SessionResult {
  /** Bearer token to pass into createPlatformApi. */
  sessionToken: string;
  /** ISO-8601 expiration timestamp, or null for non-expiring sessions. */
  expiresAt: string | null;
  /** Null for tenantless sessions (admin / pre-tenant bootstrap). */
  tenant: {
    id: string;
    slug: string;
    name: string;
  } | null;
  /** Null for tenantless sessions. */
  role: {
    id: string;
    name: string;
  } | null;
  user: {
    id: string;
    firstName: string | null;
    lastName: string | null;
  } | null;
}
/**
 * Sign in to a tenant: exchange user credentials + the tenant's publishable
 * key for a tenant-scoped Bearer session token. For the tenantless
 * platform-admin bootstrap login use `createBootstrapSession` (an
 * integration-test-only route absent from prod builds).
 *
 * Throws on any non-2xx response (e.g. 401 invalid credentials).
 */
declare function createSession(params: CreateSessionParams): Promise<SessionResult>;
/**
 * Bootstrap a TENANTLESS Bearer session (platform-admin / pre-tenant flows)
 * via `POST /api/v1/admin/bootstrap-session` — keyless by structural
 * necessity (it mints the very first Bearer of an environment, before any
 * tenant key exists). Integration-test-only: the route does not exist in
 * prod builds. Returned `tenant` and `role` are always null.
 */
declare function createBootstrapSession(params: {
  baseUrl: string;
  email: string;
  password: string;
  expiresIn?: number;
}): Promise<SessionResult>;
/**
 * Revoke the currently-configured session token. After calling this,
 * the api instance will reject every subsequent request with 401.
 */
declare function revokeSession(): Promise<void>;
/**
 * Optional HTTP-layer instrumentation hook. When provided, the SDK
 * attaches request + response interceptors to its hey-api client and
 * invokes `log` once per request and once per response.
 *
 * The SDK is logger-agnostic — `log` is a plain callback. Consumer
 * (CLI, tests, downstream apps) decides where the line goes. The same
 * pattern Stripe, AWS SDK v3, Octokit, and the OpenAI SDK use.
 *
 * `redactStrings` is consumer-supplied: every literal occurrence of
 * each entry in the formatted request / response string is replaced
 * with `********` before `log` is called. This is how secret values
 * substituted client-side (e.g. resolved from the CLI's
 * `infra.secrets.toml`) stay out of debug logs even though the SDK
 * itself never sees the placeholder syntax — it only sees the
 * resolved literal in the outgoing body, and the redaction list says
 * which literals to scrub.
 *
 * `log` receives a fully-formatted line. The URL is ABSOLUTE — origin
 * included — because the origin is the only thing distinguishing one
 * environment from another. A path-only line reads identically whether
 * the call went to localhost or to a demo server, which makes the log
 * useless for the question it is most often asked: *where did this
 * actually go?*
 *
 *   `→ POST https://demo.example.com/api/v1/tenants/foo/datalakes
 *    {
 *      "slug": "demo",
 *      "...": "..."
 *    }`
 *
 *   `← 422 https://demo.example.com/api/v1/tenants/foo/datalakes
 *    {
 *      "errors": { ... }
 *    }`
 *
 * Newlines are part of the message — caller decides whether to
 * append another. Method/status arrows (`→` `←`) make request /
 * response easy to grep.
 */
interface ApiDebugConfig {
  log: (message: string) => void;
  redactStrings?: readonly string[];
}
/**
 * `sessionToken` and `apiKey` travel together on an authorized request —
 * Firebase's "API key + ID token" split, not an either/or. `apiKey` identifies
 * the publishable client (and is what a server-side CORS check matches the
 * request's `Origin` against); `sessionToken` (Bearer) is what actually
 * authorizes the call. Neither ever substitutes for the other.
 *
 * `sessionToken` is OPTIONAL: a key-only client — the host behind an action's
 * link prefix, resolving a tap with `authenticatedLinks.exchange` on its
 * tenant's publishable key, is the usual one —
 * constructs with just `{ baseUrl, apiKey }` and sends no `Authorization`
 * header at all (never a fabricated `Bearer ` with an empty token). It
 * reaches only the limited surface the publishable key permits; everything
 * else 401s server-side, which is the intended ceiling.
 */
interface ApiConfig {
  baseUrl: string;
  sessionToken?: string;
  apiKey: string;
  debug?: ApiDebugConfig;
}
type PlatformApi = ReturnType<typeof _buildApi>;
type AlveraClient = PlatformApi;
interface DatasetSearchOptions {
  userSearchId?: string;
  /**
   * Optional override for the data access mode used by this read.
   * Defaults to the session's `data_access_mode`. The session's capability
   * ceiling still applies — escalating beyond it returns 403.
   */
  dataAccessMode?: 'raw' | 'tokenized' | 'redacted';
  /**
   * Outer SQL-chunk pagination. Defaults page=1, page_size=1000 (max 1000).
   * Pages cached IDs from `search_results`; the cap is dictated by
   * Postgres' `WHERE id IN (^ids)` plan (planner regresses past ~1k params).
   */
  outerPagination?: {
    page?: number;
    pageSize?: number;
  };
  /**
   * Inner resource Flop pagination. Defaults page=1, page_size=20.
   * Also accepts an `orderDirection` (sorts on the schema's `:global_search`
   * compound) and `globalSearch` (single ILIKE-OR text-search knob).
   */
  innerSearch?: {
    page?: number;
    pageSize?: number;
    orderDirection?: 'asc' | 'desc';
    globalSearch?: string;
  };
}
interface DatasetMetadataOptions {
  genericTableId?: string;
}
declare function createPlatformApi(config: ApiConfig): PlatformApi;
declare function createIsolatedPlatformApi(config: ApiConfig): PlatformApi;
declare function _buildApi(myClient: Client): {
  ping: () => Promise<{
    data: PingResponse;
    request: Request;
    response: Response;
  }>;
  sessions: {
    verify: () => Promise<{
      data: SessionResponse;
      request: Request;
      response: Response;
    }>;
    verifyApiKey: () => Promise<{
      data: SessionResponse;
      request: Request;
      response: Response;
    }>;
    delete: () => Promise<{
      data: unknown;
      request: Request;
      response: Response;
    }>;
  };
  admin: {
    signUp: (body: SignUpRequestWritable) => Promise<{
      data: UserResponse;
      request: Request;
      response: Response;
    }>;
    confirmUser: (id: string) => Promise<{
      data: UserResponse;
      request: Request;
      response: Response;
    }>;
    createTenantApiKey: (tenantSlug: string, body: AdminCreateTenantApiKeyRequest) => Promise<{
      data: AdminApiKeyResponse;
      request: Request;
      response: Response;
    }>;
  };
  tenants: {
    list: (query?: PlatformApiTenantControllerIndexData["query"]) => Promise<{
      data: TenantListResponse;
      request: Request;
      response: Response;
    }>;
    create: (body: TenantRequest) => Promise<{
      data: TenantResponse;
      request: Request;
      response: Response;
    }>;
  };
  invitations: {
    list: () => Promise<{
      data: InvitationListResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, body: InvitationRequest) => Promise<{
      data: InvitationResponse;
      request: Request;
      response: Response;
    }>;
    accept: (id: string) => Promise<{
      data: MembershipResponse;
      request: Request;
      response: Response;
    }>;
  };
  datasets: {
    search: (tenantSlug: string, datalakeSlug: string, dataset: string, options?: DatasetSearchOptions) => Promise<{
      data: DatasetSearchResponse;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, datasetType: string, options?: DatasetMetadataOptions) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    createUserSearch: (tenantSlug: string, datalakeSlug: string, dataset: string, body: UserSearchRequest) => Promise<{
      data: UserSearchResponse;
      request: Request;
      response: Response;
    }>;
  };
  datalakes: {
    list: (tenantSlug: string, query?: PlatformApiDatalakeControllerIndexData["query"]) => Promise<{
      data: DatalakeListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, id: string) => Promise<{
      data: DatalakeResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, body: DatalakeRequestWritable) => Promise<{
      data: DatalakeResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, body: DatalakeRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, id: string, body: DatalakeRequestWritable) => Promise<{
      data: DatalakeResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, query?: PlatformApiDatalakeControllerMetadataData["query"]) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    systemDatasets: (tenantSlug: string, datalakeSlug: string) => Promise<{
      data: SystemDatasetListResponse;
      request: Request;
      response: Response;
    }>;
    migrate: (tenantSlug: string, datalakeSlug: string) => Promise<{
      data: DatalakeMigrateResponse;
      request: Request;
      response: Response;
    }>;
    provisionTokenization: (tenantSlug: string, datalakeSlug: string) => Promise<{
      data: DatalakeResponse;
      request: Request;
      response: Response;
    }>;
    derivedLakeTables: (tenantSlug: string, datalakeSlug: string, mode: "tokenized" | "redacted") => Promise<{
      data: DerivedLakeTablesResponse;
      request: Request;
      response: Response;
    }>;
    resyncTable: (tenantSlug: string, datalakeSlug: string, mode: "tokenized" | "redacted", body: ResyncTableRequest) => Promise<{
      data: ResyncTableResponse;
      request: Request;
      response: Response;
    }>;
    createUploadLink: (tenantSlug: string, datalakeSlug: string, body: UploadLinkRequest) => Promise<{
      data: UploadLinkResponse;
      request: Request;
      response: Response;
    }>;
    createDownloadLink: (tenantSlug: string, datalakeSlug: string, body: {
      bucket: string;
      key: string;
    }) => Promise<{
      data: DownloadUrlResponse;
      request: Request;
      response: Response;
    }>;
    textToSql: (tenantSlug: string, datalakeSlug: string, body: TextToSqlRequest) => Promise<{
      data: TextToSqlResponse;
      request: Request;
      response: Response;
    }>;
    executeSql: (tenantSlug: string, datalakeSlug: string, body: ExecuteSqlRequest, options?: {
      format?: "csv";
    }) => Promise<Omit<Awaited<Promise<{
      data: ExecuteSqlResponse;
      request: Request;
      response: Response;
    }>>, "data"> & {
      data: ExecuteSqlResponse | string;
    }>;
  };
  advancedMigrations: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiAdvancedMigrationControllerIndexData["query"]) => Promise<{
      data: AdvancedMigrationListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: AdvancedMigrationResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: AdvancedMigrationRequest) => Promise<{
      data: AdvancedMigrationResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: AdvancedMigrationRequest) => Promise<{
      data: AdvancedMigrationResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: AdvancedMigrationRequest) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
  };
  dataSources: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiDataSourceControllerIndexData["query"]) => Promise<{
      data: DataSourceListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: DataSourceResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: DataSourceRequestWritable) => Promise<{
      data: DataSourceResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: DataSourceRequest) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: DataSourceRequestWritable) => Promise<{
      data: DataSourceResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
  };
  tools: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiToolControllerIndexData["query"]) => Promise<{
      data: ToolListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: ToolResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: ToolRequestWritable) => Promise<{
      data: ToolResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: ToolRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: ToolRequestWritable) => Promise<{
      data: ToolResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    testInvocation: (tenantSlug: string, datalakeSlug: string, id: string, body: ManualToolInvocationRequestWritable) => Promise<{
      data: ManualToolInvocationResponse;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
  };
  genericTables: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiGenericTableControllerIndexData["query"]) => Promise<{
      data: GenericTableListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: GenericTableResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: CreateGenericTableRequest) => Promise<{
      data: GenericTableResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: CreateGenericTableRequest) => Promise<{
      data: GenericTableResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: GenericTableRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
  };
  actionStatusUpdaters: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiActionStatusUpdaterControllerIndexData["query"]) => Promise<{
      data: ActionStatusUpdaterListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: ActionStatusUpdaterResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: CreateActionStatusUpdaterRequest) => Promise<{
      data: ActionStatusUpdaterResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: ActionStatusUpdaterRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: CreateActionStatusUpdaterRequest) => Promise<{
      data: ActionStatusUpdaterResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    refresh: (tenantSlug: string, datalakeSlug: string, id: string, body?: ActionStatusUpdaterRefreshRequest) => Promise<{
      data: ActionStatusUpdaterResponse;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
  };
  templates: {
    systemTemplates: (tenantSlug: string, datalakeSlug: string) => Promise<{
      data: SystemTemplateListResponse;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, filename: string, intent: "ai_agent" | "workflow_filter" | "workflow_decision" | "data_activation_interoperability" | "data_activation_tool_calls" | "status_poller") => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
  };
  aiAgents: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiAiAgentControllerIndexData["query"]) => Promise<{
      data: AiAgentListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: AiAgentResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: CreateAiAgentRequest) => Promise<{
      data: AiAgentResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: AiAgentRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: CreateAiAgentRequest) => Promise<{
      data: AiAgentResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    invoke: (tenantSlug: string, datalakeSlug: string, id: string, body: AiAgentInvokeRequest) => Promise<{
      data: AiAgentInvokeResponse;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
  };
  authenticatedLinks: {
    exchange: (tenantSlug: string, datalakeSlug: string, body: AuthenticatedLinkExchangeRequest) => Promise<{
      data: AuthenticatedLinkResponse;
      request: Request;
      response: Response;
    }>;
    updateMessageTracking: (tenantSlug: string, datalakeSlug: string, body: AuthenticatedLinkUpdateMessageTrackingRequest) => Promise<{
      data: AuthenticatedLinkResponse;
      request: Request;
      response: Response;
    }>;
  };
  dataActivationClients: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiDataActivationClientControllerIndexData["query"]) => Promise<{
      data: DataActivationClientListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: DataActivationClientResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: DataActivationClientRequestWritable) => Promise<{
      data: DataActivationClientResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: DataActivationClientRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: DataActivationClientRequestWritable) => Promise<{
      data: DataActivationClientResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    runManually: (tenantSlug: string, datalakeSlug: string, slug: string, body?: RunManuallyRequestWritable) => Promise<{
      data: RunManuallyResponse;
      request: Request;
      response: Response;
    }>;
    ingest: (tenantSlug: string, datalakeSlug: string, slug: string, body: IngestRequest) => Promise<{
      data: IngestResponse;
      request: Request;
      response: Response;
    }>;
    ingestFile: (tenantSlug: string, datalakeSlug: string, slug: string, body: IngestFileRequest) => Promise<{
      data: IngestFileResponse;
      request: Request;
      response: Response;
    }>;
    logs: {
      list: (tenantSlug: string, datalakeSlug: string, slug: string, query?: PlatformApiDataActivationClientControllerLogsIndexData["query"]) => Promise<{
        data: DataActivationClientLogListResponse;
        request: Request;
        response: Response;
      }>;
      get: (tenantSlug: string, datalakeSlug: string, slug: string, id: string) => Promise<{
        data: DataActivationClientLogResponse;
        request: Request;
        response: Response;
      }>;
    };
    batches: {
      list: (tenantSlug: string, datalakeSlug: string, slug: string, query?: PlatformApiDataActivationClientControllerBatchesIndexData["query"]) => Promise<{
        data: DataActivationClientBatchListResponse;
        request: Request;
        response: Response;
      }>;
      get: (tenantSlug: string, datalakeSlug: string, slug: string, batchId: string) => Promise<{
        data: DataActivationClientBatchResponse;
        request: Request;
        response: Response;
      }>;
    };
  };
  interoperabilityContracts: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiInteroperabilityContractControllerIndexData["query"]) => Promise<{
      data: InteroperabilityContractListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: InteroperabilityContractResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: InteroperabilityContractRequestWritable) => Promise<{
      data: InteroperabilityContractResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: InteroperabilityContractRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: InteroperabilityContractRequestWritable) => Promise<{
      data: InteroperabilityContractResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    run: (tenantSlug: string, datalakeSlug: string, slug: string, body: InteroperabilityRunRequest) => Promise<{
      data: InteroperabilityRunResponse;
      request: Request;
      response: Response;
    }>;
  };
  mdm: {
    verify: (tenantSlug: string, datalakeSlug: string, body: MdmVerifyRequest) => Promise<{
      data: MdmVerifyResponse;
      request: Request;
      response: Response;
    }>;
  };
  workflows: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiAgenticWorkflowControllerIndexData["query"]) => Promise<{
      data: AgenticWorkflowListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: AgenticWorkflowResponse;
      request: Request;
      response: Response;
    }>;
    create: (tenantSlug: string, datalakeSlug: string, body: AgenticWorkflowRequestWritable) => Promise<{
      data: AgenticWorkflowResponse;
      request: Request;
      response: Response;
    }>;
    checksum: (tenantSlug: string, datalakeSlug: string, body: AgenticWorkflowRequestWritable) => Promise<{
      data: ChecksumResponse;
      request: Request;
      response: Response;
    }>;
    update: (tenantSlug: string, datalakeSlug: string, id: string, body: AgenticWorkflowRequestWritable) => Promise<{
      data: AgenticWorkflowResponse;
      request: Request;
      response: Response;
    }>;
    delete: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: void;
      request: Request;
      response: Response;
    }>;
    metadata: (tenantSlug: string, datalakeSlug: string, query?: {
      page?: number;
      page_size?: number;
    }) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    metadataDetails: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: string;
      request: Request;
      response: Response;
    }>;
    execute: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, body: ExecuteActionRequest) => Promise<{
      data: ExecuteActionResponse;
      request: Request;
      response: Response;
    }>;
    run: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, body: RunWorkflowRequest) => Promise<{
      data: RunWorkflowResponse;
      request: Request;
      response: Response;
    }>;
    batchLogs: {
      list: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, query?: PlatformApiAgenticWorkflowOperationsControllerBatchLogsIndexData["query"]) => Promise<{
        data: BatchLogListResponse;
        request: Request;
        response: Response;
      }>;
      get: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, id: string) => Promise<{
        data: BatchLogResponse;
        request: Request;
        response: Response;
      }>;
      start: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, id: string) => Promise<{
        data: BatchLogResponse;
        request: Request;
        response: Response;
      }>;
      stop: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, id: string) => Promise<{
        data: BatchLogResponse;
        request: Request;
        response: Response;
      }>;
      refresh: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, id: string) => Promise<{
        data: BatchLogResponse;
        request: Request;
        response: Response;
      }>;
    };
    workflowLogs: {
      list: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, query?: PlatformApiAgenticWorkflowOperationsControllerWorkflowLogsIndexData["query"]) => Promise<{
        data: WorkflowLogListResponse;
        request: Request;
        response: Response;
      }>;
      get: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, id: string) => Promise<{
        data: WorkflowLogResponse;
        request: Request;
        response: Response;
      }>;
      download: (tenantSlug: string, datalakeSlug: string, workflowSlug: string, id: string) => Promise<{
        data: {
          url?: string;
        };
        request: Request;
        response: Response;
      }>;
    };
  };
  workflowRuns: {
    list: (tenantSlug: string, datalakeSlug: string, query?: PlatformApiWorkflowRunControllerIndexData["query"]) => Promise<{
      data: WorkflowRunListResponse;
      request: Request;
      response: Response;
    }>;
    get: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: WorkflowRunResponse;
      request: Request;
      response: Response;
    }>;
    cancel: (tenantSlug: string, datalakeSlug: string, id: string) => Promise<{
      data: WorkflowRunResponse;
      request: Request;
      response: Response;
    }>;
  };
};
//# sourceMappingURL=client.d.ts.map
//#endregion
//#region src/index.d.ts
declare function isEnvironmentName(name: string): name is EnvironmentName;
//#endregion
export { type ActionStatusUpdaterCloudWatchQueryRequest, type ActionStatusUpdaterRequestWritable, type ActionStatusUpdaterResponse, type ActionStatusUpdaterRestCallRequest, ActionType, type AdvancedMigrationListResponse, type AdvancedMigrationRequest, type AdvancedMigrationResponse, type AgenticWorkflowListResponse, type AgenticWorkflowRequestWritable, type AgenticWorkflowResponse, type AiAgentRequestWritable, type AiAgentResponse, type AlveraApiError, type AlveraClient, type ApiConfig, type ApiDebugConfig, type AuthenticatedLinkExchangeRequest, type AuthenticatedLinkResponse, type AuthenticatedLinkUpdateMessageTrackingRequest, type BatchLogListResponse, type BatchLogResponse, type CreateActionStatusUpdaterRequest, type CreateAiAgentRequest, type CreateGenericTableRequest, type CreateSessionParams, DEFAULT_ENVIRONMENT, type DataActivationClientBatchListResponse, type DataActivationClientBatchResponse, type DataActivationClientListResponse, type DataActivationClientLogListResponse, type DataActivationClientLogResponse, type DataActivationClientRequestWritable, type DataActivationClientResponse, type DataSourceRequest, type DataSourceRequestWritable, type DataSourceResponse, type DatalakeRequestWritable, type DatalakeResponse, type DatasetMetadataOptions, type DatasetSearchOptions, type DatasetSearchResponse, type DerivedLakeTablesResponse, type DownloadUrlResponse, ENVIRONMENTS, type EnvironmentName, type ErrorResponse, type ExecuteActionRequest, type ExecuteActionResponse, type ExecuteSqlMeta, type ExecuteSqlRequest, type ExecuteSqlResponse, type GenericTableColumnRequest, type GenericTableColumnResponse, type GenericTableResponse, type IngestFileRequest, type IngestRequest, type InteroperabilityContractAiAgentRequestWritable, type InteroperabilityContractListResponse, type InteroperabilityContractRequestWritable, type InteroperabilityContractResponse, type InteroperabilityRunRequest, type InteroperabilityRunResponse, type MdmVerifyRequest, type MdmVerifyResponse, type MessageResponse, type PaginationMeta, type PlatformApi, type ResyncTableRequest, type ResyncTableResponse, type RunManuallyRequestWritable, type RunManuallyResponse, type RunWorkflowRequest, type RunWorkflowResponse, type SessionResponse, type SessionResult, type TemplateConfig, type TenantListResponse, type TenantResponse, type TextToSqlRequest, type TextToSqlResponse, ToolIntent, type ToolListResponse, type ToolRequest, type ToolRequestWritable, type ToolResponse, type ToolTwilioRequest, type ToolTwilioRequestWritable, type ToolTwilioResponse, type TwilioRequest, type TwilioRequestWritable, type TwilioResponse, type UploadLinkRequest, type UploadLinkResponse, type WorkflowAiAgentRequestWritable, type WorkflowLogListResponse, type WorkflowLogResponse, type WorkflowRunListResponse, type WorkflowRunResponse, createBootstrapSession, createIsolatedPlatformApi, createPlatformApi, createSession, isEnvironmentName, revokeSession };
//# sourceMappingURL=index.d.mts.map