import * as kysely from 'kysely';
import { Kysely } from 'kysely';
export { default as KSUID } from 'ksuid';
import * as opentelemetry from '@opentelemetry/api';
import { StandardSchemaV1 } from '@standard-schema/spec';
import { LanguageModel } from 'ai';
export { z } from 'zod';

type MimeType = "application/json" | "application/gzip" | "application/pdf" | "application/rtf" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.ms-excel" | "application/vnd.ms-powerpoint" | "application/msword" | "application/zip" | "application/xml" | "application/x-7z-compressed" | "application/x-tar" | "image/gif" | "image/jpeg" | "image/svg+xml" | "image/png" | "text/html" | "text/csv" | "text/javascript" | "text/plain" | "text/calendar" | (string & {});
type InlineFileConstructor = {
    filename: string;
    contentType: MimeType;
};
type FileDbRecord = {
    key: string;
    filename: string;
    contentType: string;
    size: number;
};
declare class InlineFile {
    protected _filename: string;
    protected _contentType: MimeType;
    protected _contents: Blob | null;
    constructor(input: InlineFileConstructor);
    static fromDataURL(dataURL: string): InlineFile;
    get size(): number;
    get contentType(): string;
    get filename(): string;
    write(buffer: Buffer): void;
    read(maxBytes?: number): Promise<Buffer>;
    toDataURL(): Promise<string>;
    store(expires?: Date | null): Promise<File>;
}
declare class File extends InlineFile {
    private _key;
    private _size;
    constructor(input: Partial<FileDbRecord>);
    static fromDbRecord(input: FileDbRecord): File;
    get size(): number;
    get key(): string;
    get isPublic(): boolean;
    read(maxBytes?: number): Promise<Buffer>;
    store(expires?: Date | null): Promise<File>;
    getPresignedUrl(options?: {
        contentDisposition?: "inline" | "attachment";
        filename?: string;
    }): Promise<URL>;
    getPresignedUploadUrl(): Promise<URL>;
    toDbRecord(): FileDbRecord;
    toJSON(): FileDbRecord;
}
type FileWriteTypes = InlineFile | File;

interface RecipientUser {
    id: string;
    email?: string | null;
}
interface RecipientIdentity {
    id: string;
    email?: string | null;
}
interface EmailActionButton {
    label: string;
    url: string;
    variant?: "primary" | "secondary";
}
interface EmailDetail {
    label: string;
    value: string;
}
interface StructuredEmailContent {
    title?: string;
    body: string;
    details?: EmailDetail[];
    actions?: EmailActionButton[];
}
type EmailContent = string | StructuredEmailContent;
interface EmailRecipientGroup {
    emails?: string | string[];
    users?: string | RecipientUser | Array<string | RecipientUser>;
    identities?: string | RecipientIdentity | Array<string | RecipientIdentity>;
    teams?: string | string[];
}
interface EmailRecipients {
    to: EmailRecipientGroup;
    cc?: EmailRecipientGroup;
    bcc?: EmailRecipientGroup;
}
interface EmailInput {
    recipients: EmailRecipients;
    subject: string;
    content: EmailContent;
    replyTo?: EmailRecipientGroup;
    attachments?: FileWriteTypes[];
    branding?: boolean;
}

interface NotifyApi {
    email(input: EmailInput): Promise<string>;
}
declare function createNotifier(): NotifyApi;

declare namespace ErrorPresets {
    export { NotFoundError$1 as NotFound };
    export { BadRequestError as BadRequest };
    export { UnknownError as Unknown };
}
declare class NotFoundError$1 extends Error {
    constructor(message: any);
    errorCode: number;
}

/**
 * QueryContext is used to store state about the current query, for example
 * which joins have already been applied. It is used by applyJoins and
 * applyWhereConditions to generate consistent table aliases for joins.
 *
 * This class has the concept of a "table path". This is just a list of tables, starting
 * with some "root" table and ending with the table we're currently joining to. So
 * for example if we started with a "product" table and joined from there to "order_item"
 * and then to "order" and then to "customer" the table path would be:
 *   ["product", "order_item", "order", "customer"]
 * At this point the "current" table is "customer" and it's alias would be:
 *   "product$order_item$order$customer"
 */
declare class QueryContext {
    /**
     * @param {string[]} tablePath This is the path from the "root" table to the "current table".
     * @param {import("./ModelAPI").TableConfigMap} tableConfigMap
     * @param {string[]} joins
     */
    constructor(tablePath: string[], tableConfigMap: TableConfigMap, joins?: string[]);
    _tablePath: string[];
    _tableConfigMap: {
        [x: string]: {
            [x: string]: RelationshipConfig;
        };
    };
    _joins: string[];
    clone(): QueryContext;
    /**
     * Returns true if, given the current table path, a join to the given
     * table has already been added.
     * @param {string} table
     * @returns {boolean}
     */
    hasJoin(table: string): boolean;
    /**
     * Adds table to the QueryContext's path and registers the join,
     * calls fn, then pops the table off the path.
     * @param {string} table
     * @param {Function} fn
     */
    withJoin(table: string, fn: Function): void;
    /**
     * Returns the alias that will be used for the current table
     * @returns {string}
     */
    tableAlias(): string;
    /**
     * Returns the current table name
     * @returns {string}
     */
    tableName(): string;
    /**
     * Return the TableConfig for the current table
     * @returns {import("./ModelAPI").TableConfig | undefined}
     */
    tableConfig(): TableConfig | undefined;
}

declare class QueryBuilder {
    /**
     * @param {string} tableName
     * @param {import("./QueryContext").QueryContext} context
     * @param {import("kysely").Kysely} db
     */
    constructor(tableName: string, context: QueryContext, db: kysely.Kysely<any>);
    _tableName: string;
    _context: QueryContext;
    _db: kysely.Kysely<any>;
    _modelName: any;
    where(where: any): QueryBuilder;
    sql(): any;
    update(values: any): Promise<any>;
    delete(): Promise<any>;
    findOne(): Promise<any>;
    findMany(params: any): Promise<any>;
    /**
     * Execute query with pagination support.
     * Returns results along with pageInfo metadata.
     * @param {Object} params - Pagination parameters
     * @param {number} [params.first] - Number of items for cursor pagination (forward)
     * @param {string} [params.after] - Cursor for forward pagination
     * @param {number} [params.last] - Number of items for cursor pagination (backward)
     * @param {string} [params.before] - Cursor for backward pagination
     * @param {number} [params.limit] - Page size for offset pagination
     * @param {number} [params.offset] - Offset for offset pagination
     * @param {Object} [params.orderBy] - Ordering specification
     * @returns {Promise<{results: any[], pageInfo: Object}>}
     */
    findManyWithPageInfo(params?: {
        first?: number | undefined;
        after?: string | undefined;
        last?: number | undefined;
        before?: string | undefined;
        limit?: number | undefined;
        offset?: number | undefined;
        orderBy?: Object | undefined;
    }): Promise<{
        results: any[];
        pageInfo: Object;
    }>;
}

/**
 * TableConfig is an object where the keys are relationship field names
 * (which don't exist in the database) and the values are RelationshipConfig
 * objects describing that relationship.
 */
type RelationshipConfig = {
    relationshipType: "belongsTo" | "hasMany";
    foreignKey: string;
    referencesTable: string;
};
/**
 * TableConfigMap is mapping of database table names to TableConfig objects
 */
type TableConfig = {
    [x: string]: RelationshipConfig;
};
/**
 * RelationshipConfig is a simple representation of a model field that
 * is a relationship. It is used by applyJoins and applyWhereConditions
 * to build the correct query.
 */
type TableConfigMap = {
    [x: string]: {
        [x: string]: RelationshipConfig;
    };
};
/**
 * RelationshipConfig is a simple representation of a model field that
 * is a relationship. It is used by applyJoins and applyWhereConditions
 * to build the correct query.
 * @typedef {{
 *  relationshipType: "belongsTo" | "hasMany",
 *  foreignKey: string,
 *  referencesTable: string,
 * }} RelationshipConfig
 *
 * TableConfig is an object where the keys are relationship field names
 * (which don't exist in the database) and the values are RelationshipConfig
 * objects describing that relationship.
 * @typedef {Object.<string, RelationshipConfig} TableConfig
 *
 * TableConfigMap is mapping of database table names to TableConfig objects
 * @typedef {Object.<string, TableConfig>} TableConfigMap
 */
declare class ModelAPI {
    /**
     * @param {string} tableName The name of the table this API is for
     * @param {Function} _ Used to be a function that returns the default values for a row in this table. No longer used.
     * @param {TableConfigMap} tableConfigMap
     */
    constructor(tableName: string, _: Function, tableConfigMap?: TableConfigMap, fileFieldsMap?: {});
    _tableName: string;
    _tableConfigMap: {
        [x: string]: {
            [x: string]: RelationshipConfig;
        };
    };
    _fileFields: any;
    _modelName: any;
    create(values: any): Promise<any>;
    findOne(where?: {}): Promise<any>;
    findMany(params: any): Promise<any>;
    update(where: any, values: any): Promise<any>;
    delete(where: any): Promise<any>;
    where(where: any): QueryBuilder;
    _selectExistingFileValues(where: any, fileColumns: any): Promise<{}[]>;
    _deferReplacedFiles(existingRows: any, fileColumns: any, newRow: any): void;
}

/**
 * UnionAPI is the model API for a union: a read-only fact set assembled from several models
 * and compiled to a database view.
 *
 * A union is just a relation to read from, so this reuses ModelAPI's query machinery pointed
 * at the view, and exposes only the read methods. The generated TypeScript omits the write
 * methods entirely, so a write is a compile error; this class is the runtime half of that
 * guarantee, and Postgres refuses writes to a UNION ALL view regardless.
 */
declare class UnionAPI {
    /**
     * @param {string} viewName The name of the view this union compiles to
     * @param {import("./ModelAPI").TableConfigMap} tableConfigMap
     * @param {object} fileFieldsMap
     */
    constructor(viewName: string, tableConfigMap?: TableConfigMap, fileFieldsMap?: object);
    _model: ModelAPI;
    /**
     * Finds a single fact.
     */
    findOne(where?: {}): Promise<any>;
    /**
     * Finds multiple facts.
     */
    findMany(params: any): Promise<any>;
    /**
     * Builds a query over the fact set.
     */
    where(conditions: any): QueryBuilder;
}

/**
 * TaskAPI provides methods for creating and querying tasks.
 * It combines HTTP API calls for task actions (create, assign, complete, etc.)
 * with ModelAPI for querying (findOne, findMany).
 */
declare class TaskAPI {
    /**
     * @param {string} taskName The name of the task/topic
     * @param {Object} tableConfigMap Configuration for table relationships
     * @param {Object|null} identity Optional identity object for authentication
     * @param {string|null} authToken Optional auth token for authentication
     */
    constructor(taskName: string, tableConfigMap?: Object, identity?: Object | null, authToken?: string | null);
    _taskName: string;
    _tableName: string;
    _tableConfigMap: Object;
    _identity: Object | null;
    _authToken: string | null;
    _modelAPI: ModelAPI;
    /**
     * Returns a new TaskAPI instance that will use the given identity for authentication.
     * @param {Object} identity The identity object
     * @returns {TaskAPI} A new TaskAPI instance with the identity set
     */
    withIdentity(identity: Object): TaskAPI;
    /**
     * Returns a new TaskAPI instance that will use the given auth token for authentication.
     * @param {string} token The auth token to use
     * @returns {TaskAPI} A new TaskAPI instance with the auth token set
     */
    withAuthToken(token: string): TaskAPI;
    /**
     * Creates a new task with the given data by calling the tasks API.
     * After creation, fetches the full task data from the database to include all fields.
     * @param {Object} data The task data fields
     * @param {Object} options Optional settings like deferredUntil
     * @returns {Promise<Task>} The created task with all fields
     */
    create(data?: Object, options?: Object): Promise<Task$1>;
    /**
     * Wraps an entity with Task methods by setting its prototype and adding required fields.
     * @param {Object} entity The entity from ModelAPI
     * @returns {Task} The entity with Task methods
     */
    _wrapAsTask(entity: Object): Task$1;
    /**
     * Finds a single task matching the given conditions.
     * Returns a Task instance with both entity fields and action methods.
     * @param {Object} where Conditions to match
     * @returns {Promise<Task|null>} The Task instance or null if not found
     */
    findOne(where?: Object): Promise<Task$1 | null>;
    /**
     * Finds multiple tasks matching the given conditions.
     * Returns Task instances with both entity fields and action methods.
     * @param {Object} params Query parameters including where, limit, offset, orderBy
     * @returns {Promise<Array<Task>>} Array of Task instances
     */
    findMany(params?: Object): Promise<Array<Task$1>>;
}
/**
 * Task provides action methods for task instances.
 * These methods are attached to entities returned from findOne/findMany.
 */
declare class Task$1 {
    /**
     * Sets the identity for authentication and returns this instance.
     * @param {Object} identity The identity object
     * @returns {Task} This Task instance with the identity set
     */
    withIdentity(identity: Object): Task$1;
    _identity: Object | null | undefined;
    _authToken: string | null | undefined;
    /**
     * Sets the auth token for authentication and returns this instance.
     * @param {string} token The auth token to use
     * @returns {Task} This Task instance with the auth token set
     */
    withAuthToken(token: string): Task$1;
    /**
     * Updates the current task instance with data from the API response.
     * The API returns camelCase fields matching the Go struct JSON tags.
     * @param {Object} data The API response data
     */
    _updateFromResponse(data: Object): void;
    id: any;
    status: any;
    deferredUntil: Date | null | undefined;
    createdAt: Date | undefined;
    updatedAt: Date | undefined;
    assignedToUserId: any;
    assignedToTeam: any;
    assignedAt: Date | null | undefined;
    resolvedAt: Date | null | undefined;
    flowRunId: any;
    /**
     * Assigns the task to a user or team.
     * @param {Object} options Options containing userId or teamName (exactly one required)
     * @param {string} [options.userId] The ID of the user to assign the task to
     * @param {string} [options.teamName] The name of the team to assign the task to
     * @returns {Promise<void>}
     */
    assign({ userId, teamName }: {
        userId?: string | undefined;
        teamName?: string | undefined;
    }): Promise<void>;
    /**
     * Starts the task, creating and running the associated flow.
     * @returns {Promise<void>}
     */
    start(): Promise<void>;
    /**
     * Completes the task.
     * @returns {Promise<void>}
     */
    complete(): Promise<void>;
    /**
     * Defers the task until a specified date.
     * @param {Object} options Options containing deferUntil
     * @param {Date} options.deferUntil The date to defer the task until
     * @returns {Promise<void>}
     */
    defer({ deferUntil }: {
        deferUntil: Date;
    }): Promise<void>;
    /**
     * Cancels the task.
     * @returns {Promise<void>}
     */
    cancel(): Promise<void>;
    /**
     * Unassigns the task, removing the current assignee.
     * @returns {Promise<void>}
     */
    unassign(): Promise<void>;
}

/**
 * FlowsAPI provides methods for starting and managing flows via the HTTP API.
 */
declare class FlowsAPI {
    /**
     * @param {string} flowName The name of the flow
     * @param {Object|null} identity Optional identity object for authentication
     * @param {string|null} authToken Optional auth token for authentication
     */
    constructor(flowName: string, identity?: Object | null, authToken?: string | null);
    _flowName: string;
    _identity: Object | null;
    _authToken: string | null;
    /**
     * Returns a new FlowsAPI instance that will use the given identity for authentication.
     * @param {Object} identity The identity object
     * @returns {FlowsAPI} A new FlowsAPI instance with the identity set
     */
    withIdentity(identity: Object): FlowsAPI;
    /**
     * Returns a new FlowsAPI instance that will use the given auth token for authentication.
     * @param {string} token The auth token to use
     * @returns {FlowsAPI} A new FlowsAPI instance with the auth token set
     */
    withAuthToken(token: string): FlowsAPI;
    /**
     * Starts a new flow run with the given inputs.
     * @param {Object} inputs The flow input data
     * @returns {Promise<FlowRun>} The created flow run
     */
    start(inputs?: Object): Promise<FlowRun$1>;
    /**
     * The signed-link management namespace for this flow: create, list and revoke signed links. The
     * flow must be declared with @externalAccess (the SDK types only expose `signedLinks` on such
     * flows). By default each operation authenticates with a first-party `flows` service token that
     * the runtime trusts, so backend code can manage links without satisfying the flow's `share`
     * permission. Chaining withIdentity()/withAuthToken() switches to user-scoped auth, where the
     * flow's @permission(actions: [share]) rule is enforced.
     * @returns {{create: Function, list: Function, revoke: Function}} The signed links API
     */
    get signedLinks(): {
        create: Function;
        list: Function;
        revoke: Function;
    };
    /**
     * Gets a flow run by ID.
     * @param {string} runId The flow run ID
     * @returns {Promise<FlowRun>} The flow run
     */
    get(runId: string): Promise<FlowRun$1>;
    /**
     * Lists flow runs for this flow.
     * @param {Object} options Optional pagination options
     * @param {number} options.limit Maximum number of runs to return
     * @param {number} options.offset Offset for pagination
     * @returns {Promise<{results: FlowRun[], pageInfo: Object}>} List of flow runs with pagination info
     */
    list(options?: {
        limit: number;
        offset: number;
    }): Promise<{
        results: FlowRun$1[];
        pageInfo: Object;
    }>;
}
/**
 * FlowRun represents a flow run instance with action methods.
 */
declare class FlowRun$1 {
    /**
     * @param {Object} data The flow run data from the API
     * @param {string} flowName The name of the flow
     * @param {Object|null} identity Optional identity object for authentication
     * @param {string|null} authToken Optional auth token for authentication
     */
    constructor(data: Object, flowName: string, identity?: Object | null, authToken?: string | null);
    id: any;
    name: any;
    status: any;
    inputs: any;
    outputs: any;
    steps: any;
    pendingStep: any;
    createdAt: Date | undefined;
    updatedAt: Date | undefined;
    completedAt: Date | undefined;
    _flowName: string;
    _identity: Object | null;
    _authToken: string | null;
    /**
     * Returns a new FlowRun instance that will use the given identity for authentication.
     * @param {Object} identity The identity object
     * @returns {FlowRun} A new FlowRun instance with the identity set
     */
    withIdentity(identity: Object): FlowRun$1;
    /**
     * Returns a new FlowRun instance that will use the given auth token for authentication.
     * @param {string} token The auth token to use
     * @returns {FlowRun} A new FlowRun instance with the auth token set
     */
    withAuthToken(token: string): FlowRun$1;
    /**
     * Converts the flow run back to API data format for creating new instances.
     * @returns {Object} The flow run data in API format
     */
    _toApiData(): Object;
    /**
     * Refreshes the flow run state from the API.
     * @returns {Promise<FlowRun>} The updated flow run
     */
    refresh(): Promise<FlowRun$1>;
    /**
     * Cancels the flow run.
     * @returns {Promise<FlowRun>} The updated flow run
     */
    cancel(): Promise<FlowRun$1>;
}

declare function createIntegrationServer(name: any, identity: any): {
    do: (request: any) => Promise<any>;
};

type ModuleExportsContext = {
    name: string;
    server: unknown;
    secret(key: string): string;
};
type ModuleExportsFactory<C extends ModuleExportsContext = ModuleExportsContext, T extends object = object> = (ctx: C) => T;
declare function defineModuleExports<T extends object>(factory: ModuleExportsFactory<ModuleExportsContext, T>): ModuleExportsFactory<ModuleExportsContext, T>;
declare function registerModuleExports(map: Record<string, ModuleExportsFactory | undefined>): void;
declare function buildModuleAPI(name: string, base: Omit<ModuleExportsContext, "name">): Record<string, unknown>;

interface RequestHeadersMap {
    [key: string]: string;
}
declare class RequestHeaders {
    private _headers;
    /**
     * @param {{Object.<string, string>}} requestHeaders Map of request headers submitted from the client
     */
    constructor(requestHeaders: RequestHeadersMap);
    get: Headers["get"];
    has: Headers["has"];
}

declare function handleRequest(request: any, config: any): Promise<any>;

declare function handleJob(request: any, config: any): Promise<any>;

declare function handleSubscriber(request: any, config: any): Promise<any>;

declare function handleRoute(request: any, config: any): Promise<any>;

declare function handleFlow(request: any, config: any): Promise<any>;

declare function useDatabase(): Kysely<any>;

declare const PERMISSION_STATE: {
    readonly UNKNOWN: "unknown";
    readonly PERMITTED: "permitted";
    readonly UNPERMITTED: "unpermitted";
};
type PermissionState = (typeof PERMISSION_STATE)[keyof typeof PERMISSION_STATE];
/**
 * Permissions class for managing access control in the runtime
 */
declare class Permissions {
    /**
     * Explicitly permit access to an action
     */
    allow(): void;
    /**
     * Explicitly deny access to an action
     */
    deny(): never;
    getState(): PermissionState;
}
interface CheckBuiltInPermissionsParams {
    rows: any[];
    permissionFns: Array<(rows: any[], ctx: any, db: any) => Promise<boolean>>;
    ctx: any;
    db: any;
    functionName: string;
}
declare const checkBuiltInPermissions: ({ rows, permissionFns, ctx, db, functionName, }: CheckBuiltInPermissionsParams) => Promise<void>;

declare namespace ATTRS {
    let ACTION: string;
    let ACTION_TYPE: string;
    let ACTION_IMPLEMENTATION: string;
    let MODEL: string;
    let API: string;
    let PROTOCOL: string;
    let KIND: string;
    let LOG_SOURCE: string;
    let LOG_RAW: string;
    let IDENTITY_ID: string;
    let JOB_NAME: string;
    let JOB_ID: string;
    let EVENT_NAME: string;
    let EVENT_TARGET_TYPE: string;
    let EVENT_TARGET_ID: string;
    let SUBSCRIBER: string;
    let SUBSCRIBER_ID: string;
    let FLOW_NAME: string;
    let FLOW_RUN_ID: string;
    let STEP_NAME: string;
    let STEP_TYPE: string;
    let STEP_STATUS: string;
    let STEP_ID: string;
    let STEP_EXPECTED_ID: string;
    let STEP_ELEMENT: string;
    let STEP_CALLBACK: string;
    let TRIGGER: string;
    let GRAPHQL_QUERY_BYTES: string;
    let GRAPHQL_OPERATION: string;
    let GRAPHQL_DEMAND: string;
    let GRAPHQL_METADATA_DEMAND: string;
    let PERMISSION_RESULT: string;
    let VALIDATION_RESULT: string;
    let VALIDATION_RULES: string;
    let VALIDATION_RULES_FAILED: string;
    let VALIDATION_FAILED_RULES: string;
    let PERMISSION_REASON: string;
    let INTERNAL: string;
    let STATUS: string;
    let ATTEMPT: string;
    let EVENTS_GENERATED: string;
    let FLOW_STATUS: string;
    let FLOW_DURATION_MS: string;
    let MIGRATION_DRY_RUN: string;
    let MIGRATION_CHANGES: string;
    let MIGRATION_CHANGES_ADDED: string;
    let MIGRATION_CHANGES_REMOVED: string;
    let MIGRATION_CHANGES_MODIFIED: string;
    let MIGRATION_BACKFILL_TABLE: string;
    let MIGRATION_BACKFILL_WINDOWS: string;
    let MIGRATION_BACKFILL_ROWS_CORRECTED: string;
    let MIGRATION_BACKFILL_CHECKPOINT: string;
    let MIGRATION_BACKFILL_LOCK_RETRIES: string;
    let MIGRATION_BACKFILL_RESUMED_FROM: string;
    let MIGRATION_BACKFILL_DURATION_MS: string;
    let MIGRATION_BACKFILL_ELAPSED_MS: string;
    let MIGRATION_BACKFILL_STOP_REASON: string;
    let MIGRATION_DEFERRED_BUDGET_MS: string;
    let MIGRATION_DEFERRED_DONE: string;
    let MIGRATION_DEFERRED_PENDING: string;
    let MIGRATION_GUARDED_DDL_ATTEMPT: string;
    let MIGRATION_GUARDED_DDL_STATEMENT: string;
    let EVENT_PAYLOAD_BYTES: string;
    let RESPONSE_CODE: string;
    let RESPONSE_BYTES: string;
    let CREATE_FIELDS: string;
    let UPDATE_FIELDS: string;
    let UPDATE_WHERE: string;
    let GET_EMBEDS: string;
    let LIST_WHERE: string;
    let LIST_ORDER_BY: string;
    let LIST_SEARCH: string;
    let LIST_FACETS: string;
    let LIST_PAGE_FIRST: string;
    let LIST_PAGE_HAS_CURSOR: string;
    let LIST_PAGE_LAST: string;
    let LIST_PAGE_LIMIT: string;
    let LIST_PAGE_OFFSET: string;
    let LIST_RESULTS_COUNT: string;
    let AUTH_ISSUER: string;
    let IDENTITY_EXTERNAL_ID: string;
    let USER_ID: string;
    let AUTH_EMAIL_LOOKUP: string;
    let AUTH_USER_PROVISIONING: string;
    let OUTCOME: string;
    let AUTH_ERROR: string;
    let AUTH_ERROR_DESCRIPTION: string;
    let FLOW_COUNT: string;
    let FLOW_METADATA_ONLY: string;
    let FLOW_SCHEDULED_AT: string;
    let MIGRATION_STATEMENTS: string;
    let TIMEZONE: string;
    let FILES_DELETED: string;
    let UPLOAD_ACTION: string;
    let UPLOAD_FIELD: string;
    let STEP_VALUE_BYTES: string;
    let STEP_RENDERED: string;
    let AUDIENCE: string;
    let SPAN_TYPE: string;
    let QUEUED_MS: string;
    let LEDGER: string;
    let LEDGER_GROUP: string;
    let LEDGER_ENTRIES: string;
    let LEDGER_POSITIONS: string;
    let INTEGRATION: string;
    let INTEGRATION_ATTEMPTS: string;
    let INTEGRATION_TOKEN_REFRESH: string;
    let INTEGRATION_REQUEST_ID: string;
    let INTEGRATION_REPLAY_OF: string;
    let INTEGRATION_REQUESTS_SHED: string;
    let INTEGRATION_REQUESTS_DELETED: string;
    let SYNC_INTEGRATION: string;
    let SYNC_ENTITY: string;
    let SYNC_SCOPE: string;
    let SYNC_STRATEGY: string;
    let SYNC_PHASE: string;
    let SYNC_MODE: string;
    let SYNC_PAGE: string;
    let SYNC_RECONCILE_ID: string;
    let SYNC_RECORDS_FETCHED: string;
    let SYNC_RECORDS_CHANGED: string;
    let SYNC_RECORDS_APPLIED: string;
    let SYNC_RECORDS_FAILED: string;
    let SYNC_RECORDS_SKIPPED: string;
    let SYNC_RECORDS_TOMBSTONED: string;
    let SYNC_RECORDS_LIVE: string;
    let SYNC_RECORDS_ATTEMPTED: string;
    let SYNC_RECORD_EXTERNAL_ID: string;
    let SYNC_RECORD_ATTEMPTS: string;
    let SYNC_RATE_LIMIT_REMAINING: string;
    let SYNC_RATE_LIMIT_RESERVE: string;
    let SYNC_ACTION: string;
}

declare function getTracer(): opentelemetry.Tracer;
declare function withSpan(name: any, fn: any, opts?: {}): Promise<any>;
declare function withUserSpan(span: any, fn: any): any;
declare function init(): void;
declare function forceFlush(): Promise<void>;
declare function createTraceAPI$1(defaultSpan: any): {
    readonly traceId: any;
    readonly spanId: any;
    setAttribute(key: any, value: any): void;
    setAttributes(attributes: any): void;
};
declare function withDbQuerySpan(modelName: any, action: any, fn: any): Promise<any>;
declare function spanNameForServiceAPI(service: any, op: any): string;
declare function fetchUntraced(...args: any[]): any;
declare const TRACER_NAME: "keel.functions";

declare const KEEL_INTERNAL_ATTR: string;
declare const KEEL_INTERNAL_TRUE: "true";
declare const KEEL_INTERNAL_CHILDREN: "children";
declare const SpanKind: typeof opentelemetry.SpanKind;
declare function truncateSQL(s: any): any;
declare function markUserFacing(span: any, archetype: any): void;
declare function withUserFacingSpan(archetype: any, attrs: any, fn: any, opts?: {}): Promise<any>;
declare const AUDIENCE_USER: "user";
declare const ARCHETYPE_CUSTOM: "custom";
declare function getUserTracingRegistry(): any;

declare const tracing_ARCHETYPE_CUSTOM: typeof ARCHETYPE_CUSTOM;
declare const tracing_ATTRS: typeof ATTRS;
declare const tracing_AUDIENCE_USER: typeof AUDIENCE_USER;
declare const tracing_KEEL_INTERNAL_ATTR: typeof KEEL_INTERNAL_ATTR;
declare const tracing_KEEL_INTERNAL_CHILDREN: typeof KEEL_INTERNAL_CHILDREN;
declare const tracing_KEEL_INTERNAL_TRUE: typeof KEEL_INTERNAL_TRUE;
declare const tracing_SpanKind: typeof SpanKind;
declare const tracing_TRACER_NAME: typeof TRACER_NAME;
declare const tracing_fetchUntraced: typeof fetchUntraced;
declare const tracing_forceFlush: typeof forceFlush;
declare const tracing_getTracer: typeof getTracer;
declare const tracing_getUserTracingRegistry: typeof getUserTracingRegistry;
declare const tracing_init: typeof init;
declare const tracing_markUserFacing: typeof markUserFacing;
declare const tracing_spanNameForServiceAPI: typeof spanNameForServiceAPI;
declare const tracing_truncateSQL: typeof truncateSQL;
declare const tracing_withDbQuerySpan: typeof withDbQuerySpan;
declare const tracing_withSpan: typeof withSpan;
declare const tracing_withUserFacingSpan: typeof withUserFacingSpan;
declare const tracing_withUserSpan: typeof withUserSpan;
declare namespace tracing {
  export { tracing_ARCHETYPE_CUSTOM as ARCHETYPE_CUSTOM, tracing_ATTRS as ATTRS, tracing_AUDIENCE_USER as AUDIENCE_USER, tracing_KEEL_INTERNAL_ATTR as KEEL_INTERNAL_ATTR, tracing_KEEL_INTERNAL_CHILDREN as KEEL_INTERNAL_CHILDREN, tracing_KEEL_INTERNAL_TRUE as KEEL_INTERNAL_TRUE, tracing_SpanKind as SpanKind, tracing_TRACER_NAME as TRACER_NAME, createTraceAPI$1 as createTraceAPI, tracing_fetchUntraced as fetchUntraced, tracing_forceFlush as forceFlush, tracing_getTracer as getTracer, tracing_getUserTracingRegistry as getUserTracingRegistry, tracing_init as init, tracing_markUserFacing as markUserFacing, tracing_spanNameForServiceAPI as spanNameForServiceAPI, tracing_truncateSQL as truncateSQL, tracing_withDbQuerySpan as withDbQuerySpan, tracing_withSpan as withSpan, tracing_withUserFacingSpan as withUserFacingSpan, tracing_withUserSpan as withUserSpan };
}

declare class Duration {
    private _typename;
    private pgInterval;
    private _interval;
    constructor(postgresString: string);
    static fromISOString(isoString: string): Duration;
    toISOString(): string;
    toPostgres(): string;
}

type ActionInputs<T> = T extends File ? FileWriteTypes : T extends InlineFile | Date | Duration ? T : T extends Array<infer U> ? ActionInputs<U>[] : T extends object ? {
    [K in keyof T]: ActionInputs<T[K]>;
} : T;
type ActionPaths = Record<string, string>;
type ActionsAPIOptions = {
    authToken?: string | null;
    timezone?: string | null;
};
/**
 * ActionsAPI calls schema-defined actions over the runtime's public JSON API, as the identity the
 * current invocation runs as.
 *
 * The generated SDK exposes a single instance as `actions`, with a typed method per action. This
 * class provides no such methods itself: a Proxy turns any unknown property access into a call to
 * `execute`, so codegen only has to emit type declarations.
 *
 * Who the action runs as - the runtime applies that identity's permission rules, @where filters and
 * row-level checks exactly as it would for an API request; there is no backend bypass:
 *   1. withAuthToken(token) -> that token is sent; the runtime resolves the caller from it.
 *   2. otherwise            -> the access token of the invocation this call is made from: the token
 *      the function's caller presented, or one the runtime minted for a flow's or job's identity.
 *      An anonymous invocation (a subscriber, an unauthenticated request) calls anonymously.
 *
 * Options are immutable: each with* method returns a new instance, so an instance handed out by
 * the SDK can never be re-scoped by a caller elsewhere.
 */
declare class ActionsAPI {
    private readonly _paths;
    private readonly _authToken;
    private readonly _timezone;
    constructor(paths?: ActionPaths, opts?: ActionsAPIOptions);
    /**
     * Returns a new ActionsAPI that authenticates with the given token instead of the invocation's own.
     */
    withAuthToken(token: string): ActionsAPI;
    /**
     * Returns a new ActionsAPI that evaluates the action's relative dates in the given timezone.
     */
    withTimezone(timezone: string): ActionsAPI;
    /**
     * Calls the named action with the given inputs, returning its result. Throws an ActionError
     * when the runtime rejects the call or the request itself fails.
     */
    execute(actionName: string, inputs?: Record<string, unknown>): Promise<any>;
    private _buildHeaders;
}

declare const ACTION_ERROR_CODES: readonly ["ERR_INTERNAL", "ERR_INVALID_INPUT", "ERR_INPUT_MALFORMED", "ERR_AUTHENTICATION_FAILED", "ERR_PERMISSION_DENIED", "ERR_RECORD_NOT_FOUND", "ERR_ACTION_NOT_FOUND", "ERR_HTTP_METHOD_NOT_ALLOWED", "ERR_UNKNOWN", "ERR_REQUEST_BODY_TOO_LARGE", "ERR_CONFLICT", "ERR_LEDGER_GUARD"];
type ActionErrorCode = (typeof ACTION_ERROR_CODES)[number];
type ActionValidationErrorData = {
    errors: {
        field: string;
        error: string;
    }[];
};
type ActionLedgerErrorData = {
    entryIndex: number;
};
type ActionLedgerGuardKind = "min" | "max";
type ActionLedgerBalanceGuardError = {
    error: string;
    guard: ActionLedgerGuardKind;
    bound: number;
    balance: string;
    position: Record<string, unknown>;
    current: number;
    attempted: number;
};
type ActionLedgerAmountGuardError = {
    error: string;
    guard: ActionLedgerGuardKind;
    bound: number;
    amount: string;
    value: number;
    entryIndex?: number;
};
type ActionLedgerRelatedRowGuardError = {
    error: string;
    guard: ActionLedgerGuardKind;
    bound: number;
    ledger: string;
    balance: string;
};
type ActionLedgerGuardErrorData = {
    errors: (ActionLedgerBalanceGuardError | ActionLedgerAmountGuardError | ActionLedgerRelatedRowGuardError | {
        error: string;
    })[];
};
type ActionErrorInit = {
    action: string;
    code: ActionErrorCode;
    message: string;
    status: number;
    data?: Record<string, unknown>;
    cause?: unknown;
};
declare class ActionError extends Error {
    readonly name = "ActionError";
    readonly code: ActionErrorCode;
    readonly status: number;
    readonly action: string;
    readonly data?: Record<string, unknown>;
    readonly cause?: unknown;
    constructor(init: ActionErrorInit);
}
declare function isActionError(e: unknown, code?: ActionErrorCode): e is ActionError;

type TraceAttributePrimitive = string | number | boolean;
type TraceAttributeValue = TraceAttributePrimitive | string[] | number[] | boolean[];
type TraceAttributes = Record<string, TraceAttributeValue | undefined>;
type TraceAPI = {
    readonly traceId: string;
    readonly spanId: string;
    setAttribute(key: string, value: TraceAttributeValue | undefined): void;
    setAttributes(attributes: TraceAttributes): void;
};

type LogFields = Record<string, unknown>;
declare const log: {
    debug: (msg: string, fields?: LogFields) => void;
    info: (msg: string, fields?: LogFields) => void;
    warn: (msg: string, fields?: LogFields) => void;
    error: (msg: string, fields?: LogFields) => void;
};

/**
 * Type-level tokenizer for the visibility expression subset of CEL. Runs entirely in the type
 * system: `Tokenize<"a >= 10">` is `[{ id: "a" }, ">=", { num: "10" }]`. Every recursive step is
 * in tail position so TypeScript's tail-call evaluation applies.
 */
type Ws = " " | "\t" | "\n" | "\r";
type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
type Lower = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
type IdentStart = Lower | Uppercase<Lower> | "_";
type IdentChar = IdentStart | Digit;
type TwoCharOp = "==" | "!=" | "<=" | ">=" | "&&" | "||";
type OneCharOp = "<" | ">" | "!" | "(" | ")" | "[" | "]" | "," | ".";
/** CEL keywords; they cannot follow `inputs.` as a field selector, use `inputs["..."]` instead. */
type CelKeyword = "as" | "break" | "const" | "continue" | "else" | "for" | "function" | "if" | "import" | "let" | "loop" | "package" | "namespace" | "return" | "var" | "void" | "while" | "true" | "false" | "null" | "in";
/** Aggregates over an iterator's rows, spelled as in schema expressions. */
type AggregateFn = "COUNT" | "ANY" | "ALL" | "SUM" | "MIN" | "MAX";
/**
 * Text functions, spelled as Keel functions: `STARTSWITH(inputs.code, "D-")`. The wire carries
 * CEL's receiver form (`inputs.code.startsWith("D-")`), which is the only spelling CEL defines.
 */
type StringFn = "STARTSWITH" | "ENDSWITH" | "CONTAINS" | "MATCHES";
/** CEL's receiver-style names, recognised only to point authors at the Keel spelling. */
type StringMethod = "contains" | "startsWith" | "endsWith" | "matches";
type MethodToFn<M extends StringMethod> = M extends "contains" ? "CONTAINS" : M extends "startsWith" ? "STARTSWITH" : M extends "endsWith" ? "ENDSWITH" : "MATCHES";
type CmpOp = "==" | "!=" | "<" | "<=" | ">" | ">=";
type Keyword = "true" | "false" | "null" | "in";
type Tok = TwoCharOp | OneCharOp | Keyword | {
    id: string;
} | {
    str: string;
} | {
    num: string;
};
type Err<M extends string = string> = {
    err: M;
};
type MatchOp<S extends string, Ops extends string> = Ops extends infer O extends string ? S extends `${O}${infer R}` ? [O, R] : never : never;
type FirstOp<S extends string, Ops extends string> = [MatchOp<S, Ops>] extends [
    never
] ? null : MatchOp<S, Ops>;
type ScanIdent<S extends string, Acc extends string = ""> = S extends `${infer C extends IdentChar}${infer R}` ? ScanIdent<R, `${Acc}${C}`> : [Acc, S];
type ScanDigits<S extends string, Acc extends string> = S extends `${infer C extends Digit}${infer R}` ? ScanDigits<R, `${Acc}${C}`> : [Acc, S];
type ScanNum<S extends string, Acc extends string = ""> = ScanDigits<S, Acc> extends [infer I extends string, infer R extends string] ? R extends `.${infer D extends Digit}${infer R2}` ? ScanDigits<R2, `${I}.${D}`> : [I, R] : never;
type Word<Id extends string> = Id extends Keyword ? Id : {
    id: Id;
};
type Tokenize<S extends string, Acc extends Tok[] = []> = S extends "" ? Acc : S extends `${Ws}${infer R}` ? Tokenize<R, Acc> : FirstOp<S, TwoCharOp> extends [
    infer O extends Tok,
    infer R extends string
] ? Tokenize<R, [...Acc, O]> : FirstOp<S, OneCharOp> extends [
    infer O extends Tok,
    infer R extends string
] ? Tokenize<R, [...Acc, O]> : S extends `"${infer Str}"${infer R}` ? Tokenize<R, [...Acc, {
    str: Str;
}]> : S extends `'${infer Str}'${infer R}` ? Tokenize<R, [...Acc, {
    str: Str;
}]> : S extends `-${Digit}${string}` ? (S extends `-${infer R}` ? ScanNum<R, "-"> : never) extends [
    infer N extends string,
    infer R extends string
] ? Tokenize<R, [...Acc, {
    num: N;
}]> : never : S extends `${Digit}${string}` ? ScanNum<S> extends [
    infer N extends string,
    infer R extends string
] ? Tokenize<R, [...Acc, {
    num: N;
}]> : never : S extends `${IdentStart}${string}` ? ScanIdent<S> extends [
    infer Id extends string,
    infer R extends string
] ? Tokenize<R, [...Acc, Word<Id>]> : never : S extends `${infer C}${string}` ? Err<`Unexpected character '${C}'`> : never;
/** Human-readable rendering of a token for "near ..." messages. */
type TokText<T> = T extends string ? T : T extends {
    id: infer I extends string;
} ? I : T extends {
    str: infer S extends string;
} ? `"${S}"` : T extends {
    num: infer N extends string;
} ? N : "?";

/**
 * Value categories and typing rules for the visibility expression subset. Identifiers take their
 * category from the input's `valueType`; literals from their token.
 */

type TBool = {
    k: "bool";
};
type TNum = {
    k: "num";
};
/** A string-valued field; `u` is the union of values it can hold (`string` when unconstrained). */
type TStr<U extends string = string> = {
    k: "str";
    u: U;
};
/** A quoted literal in the expression. */
type TLit<S extends string = string> = {
    k: "lit";
    lit: S;
};
type TList = {
    k: "list";
};
type TNull = {
    k: "null";
};
/** Object-valued fields (files, table rows, pick lists): only comparable with null. */
type TOther = {
    k: "other";
};
/** Fields whose value type is `any`; nothing is checked. */
type TAny = {
    k: "any";
};
/** An iterator: a list of rows whose fields are described by `R` (a row `CelCtx`). */
type TRows<R = unknown> = {
    k: "rows";
    rows: R;
};
/** Brand on a `CelCtx` entry that marks an iterator; `R` is the row context. */
declare const rowsBrand: unique symbol;
type Rows<R> = {
    readonly [rowsBrand]: R;
};
/** Brand on a `CelCtx` saying whether it is a page (aggregates allowed) or an iterator row. */
declare const scopeBrand: unique symbol;
type ScopeKind = "page" | "row";
/** Brand set on a `CelCtx` while parsing an `ANY`/`ALL` body: the iterator being quantified. */
declare const quantifiedBrand: unique symbol;
type IsAny<V> = 0 extends 1 & V ? true : false;
type TyOf<V> = IsAny<V> extends true ? TAny : V extends Rows<infer R> ? TRows<R> : [V] extends [boolean] ? TBool : [V] extends [number] ? TNum : [V] extends [string] ? TStr<V> : [V] extends [readonly unknown[]] ? TList : TOther;
/** The type of a field reference; carries the field name for messages. */
type IdentTy<N extends string, V> = TyOf<NonNullable<V>> & {
    name: N;
};
type KindOf<T> = T extends {
    k: "lit";
} ? "str" : T extends {
    k: infer K;
} ? K : never;
type KindName<T> = KindOf<T> extends "num" ? "a number" : KindOf<T> extends "bool" ? "a boolean" : KindOf<T> extends "str" ? "text" : KindOf<T> extends "list" ? "a list" : KindOf<T> extends "null" ? "null" : KindOf<T> extends "rows" ? "an iterator" : "an object";
/** How an operand is named in a message. */
type Desc<T> = T extends {
    k: "rows";
    name: infer N extends string;
} ? `iterator '${N}'` : T extends {
    name: infer N extends string;
} ? `field '${N}'` : T extends TLit<infer S> ? `'${S}'` : T extends {
    num: infer N extends string;
} ? N : KindName<T>;
type IsAnyTy<T> = T extends {
    k: "any";
} ? true : false;
type Either<L, R, K extends string> = KindOf<L> extends K ? true : KindOf<R> extends K ? true : false;
type CheckMembership<L, R> = L extends TStr<infer U> & {
    name: infer N extends string;
} ? R extends TLit<infer S> ? S extends U ? true : Err<`'${S}' is not one of the options of ${Desc<L>}`> : true : R extends TStr<infer U> & {
    name: infer N extends string;
} ? L extends TLit<infer S> ? S extends U ? true : Err<`'${S}' is not one of the options of ${Desc<R>}`> : true : true;
type CheckEq<L, R> = IsAnyTy<L> extends true ? true : IsAnyTy<R> extends true ? true : Either<L, R, "rows"> extends true ? Err<`${Desc<L extends {
    k: "rows";
} ? L : R>} can only be used inside COUNT, ANY, ALL, SUM, MIN or MAX`> : Either<L, R, "null"> extends true ? true : Either<L, R, "other"> extends true ? Err<`${Desc<L extends {
    k: "other";
} ? L : R>} can only be compared with null`> : Either<L, R, "list"> extends true ? Err<`${Desc<L extends {
    k: "list";
} ? L : R>} is a list; use size(...) or compare it with null`> : KindOf<L> extends KindOf<R> ? CheckMembership<L, R> : Err<`Cannot compare ${Desc<L>} (${KindName<L>}) with ${Desc<R>} (${KindName<R>})`>;
type CheckOrd<L, R, Op extends string> = IsAnyTy<L> extends true ? true : IsAnyTy<R> extends true ? true : KindOf<L> extends "num" ? KindOf<R> extends "num" ? true : Err<`'${Op}' needs two numbers or two strings, got ${Desc<L>} and ${Desc<R>}`> : KindOf<L> extends "str" ? KindOf<R> extends "str" ? true : Err<`'${Op}' needs two numbers or two strings, got ${Desc<L>} and ${Desc<R>}`> : Err<`'${Op}' needs two numbers or two strings, got ${Desc<L>} and ${Desc<R>}`>;
type CheckItems<L, Items> = Items extends [infer I, ...infer Rest] ? CheckEq<L, I> extends Err<infer M extends string> ? Err<M> : CheckItems<L, Rest> : true;
type CheckIn<L, Items> = IsAnyTy<L> extends true ? true : KindOf<L> extends "bool" | "num" | "str" ? CheckItems<L, Items> : Err<`'in' needs a boolean, number or text on the left, got ${Desc<L>}`>;
type RequireBool<T, Op extends string> = IsAnyTy<T> extends true ? true : KindOf<T> extends "bool" ? true : Err<`Operand of '${Op}' must be a boolean, got ${Desc<T>}`>;
type StringFnOn<T, Fn extends string> = KindOf<T> extends "str" | "any" ? TBool : Err<`${Fn}() needs a text field, ${Desc<T>} is ${KindName<T>}`>;
type SizeOf<T> = KindOf<T> extends "list" | "str" | "any" ? TNum : KindOf<T> extends "rows" ? Err<`size() does not apply to iterators; write COUNT(inputs.${T extends {
    name: infer N extends string;
} ? N : "lines"}) instead`> : Err<`size() needs a list or text field, ${Desc<T>} is ${KindName<T>}`>;
/** `SUM`/`MIN`/`MAX` need a numeric row field. */
type NumericRowField<T, Fn extends string> = KindOf<T> extends "num" | "any" ? TNum : Err<`${Fn}() needs a number field, ${Desc<T>} is ${KindName<T>}`>;

/**
 * Type-level recursive-descent parser for the visibility expression subset of CEL:
 *
 *   expr    := or ;  or := and ("||" and)* ;  and := cmp ("&&" cmp)*
 *   cmp     := unary (("=="|"!="|"<"|"<="|">"|">=") unary | "in" list)? ;  unary := "!" unary | primary
 *
 * `!` binds tighter than comparisons, as in CEL: `!a == 1` is `(!a) == 1`, so negating a whole
 * comparison needs parentheses.
 *   primary := "(" expr ")" | field | literal | "size" "(" field ")"
 *            | ("STARTSWITH"|"ENDSWITH"|"CONTAINS"|"MATCHES") "(" field "," string ")"
 *            | "COUNT" "(" field ")" | ("SUM"|"MIN"|"MAX") "(" rowPath ")" | ("ANY"|"ALL") "(" expr ")"
 *   field   := "inputs" "." ident | "inputs" "[" string "]"
 *   rowPath := field "." ident | field "[" string "]"        (field must be an iterator)
 *
 * Aggregates are page-scope only. Inside an ANY/ALL body exactly one iterator is quantified, and
 * its row paths resolve to the row's field types; `inputs.<pageInput>` still resolves to the page.
 *   literal := "…" | '…' | number | true | false | null ;  list := "[" literal ("," literal)* "]"
 *
 * Each level returns `[Ty, RemainingTokens]` or an `Err`. Repetition is handled by tail helpers so
 * instantiation depth grows only with parenthesis nesting.
 */

type Step$1<Ty, Rest extends Tok[]> = [Ty, Rest];
type Fail<R> = R extends Err ? R : never;
type ParseOr<Toks extends Tok[], Ctx> = ParseAnd<Toks, Ctx> extends infer A ? A extends Step$1<infer L, infer R> ? OrTail<L, R, Ctx> : Fail<A> : never;
type OrTail<L, Toks extends Tok[], Ctx> = Toks extends [
    "||",
    ...infer R extends Tok[]
] ? ParseAnd<R, Ctx> extends infer B ? B extends Step$1<infer L2, infer R2> ? RequireBool<L, "||"> extends Err<infer M extends string> ? Err<M> : RequireBool<L2, "||"> extends Err<infer M extends string> ? Err<M> : OrTail<TBool, R2, Ctx> : Fail<B> : never : Step$1<L, Toks>;
type ParseAnd<Toks extends Tok[], Ctx> = ParseCmp<Toks, Ctx> extends infer A ? A extends Step$1<infer L, infer R> ? AndTail<L, R, Ctx> : Fail<A> : never;
type AndTail<L, Toks extends Tok[], Ctx> = Toks extends [
    "&&",
    ...infer R extends Tok[]
] ? ParseCmp<R, Ctx> extends infer B ? B extends Step$1<infer L2, infer R2> ? RequireBool<L, "&&"> extends Err<infer M extends string> ? Err<M> : RequireBool<L2, "&&"> extends Err<infer M extends string> ? Err<M> : AndTail<TBool, R2, Ctx> : Fail<B> : never : Step$1<L, Toks>;
type ParseUnary<Toks extends Tok[], Ctx> = Toks extends [
    "!",
    ...infer R extends Tok[]
] ? ParseUnary<R, Ctx> extends infer U ? U extends Step$1<infer T, infer R2> ? RequireBool<T, "!"> extends Err<infer M extends string> ? Err<M> : Step$1<TBool, R2> : Fail<U> : never : ParsePrimary<Toks, Ctx>;
type ParseCmp<Toks extends Tok[], Ctx> = ParseUnary<Toks, Ctx> extends infer P ? P extends Step$1<infer L, infer R> ? R extends [infer Op extends CmpOp, ...infer R2 extends Tok[]] ? ParseUnary<R2, Ctx> extends infer Q ? Q extends Step$1<infer L2, infer R3> ? (Op extends "==" | "!=" ? CheckEq<L, L2> : CheckOrd<L, L2, Op>) extends Err<infer M extends string> ? Err<M> : Step$1<TBool, R3> : Fail<Q> : never : R extends ["in", ...infer R2 extends Tok[]] ? ParseList<R2> extends infer LS ? LS extends Step$1<infer Items, infer R3> ? CheckIn<L, Items> extends Err<infer M extends string> ? Err<M> : Step$1<TBool, R3> : Fail<LS> : never : Step$1<L, R> : Fail<P> : never;
type ParseKey<Toks extends Tok[], Prefix extends string = "inputs"> = Toks extends [".", {
    id: infer N extends string;
}, ...infer R extends Tok[]] ? N extends CelKeyword ? Err<`'${N}' is a CEL keyword; write ${Prefix}["${N}"] instead`> : [N, R] : Toks extends [
    "[",
    {
        str: infer N extends string;
    },
    "]",
    ...infer R extends Tok[]
] ? [N, R] : never;
type IsRows<V> = 0 extends 1 & V ? false : V extends Rows<any> ? true : false;
type RowCtxOf<Ctx, Iter extends string> = Iter extends keyof Ctx ? Ctx[Iter] extends Rows<infer R> ? R : never : never;
type ParseFieldRef<Toks extends Tok[], Ctx> = Toks extends [
    {
        id: "inputs";
    },
    ...infer R extends Tok[]
] ? ParseKey<R> extends infer K ? [K] extends [never] ? Err<'Inputs are referenced as inputs.name or inputs["name"]'> : K extends [infer N extends string, infer R2 extends Tok[]] ? N extends keyof Ctx ? IsRows<Ctx[N]> extends true ? ParseKey<R2, `inputs.${N}`> extends infer K2 ? [K2] extends [never] ? Step$1<TRows<RowCtxOf<Ctx, N>> & {
    name: N;
}, R2> : K2 extends [infer F extends string, infer R3 extends Tok[]] ? Ctx extends {
    readonly [quantifiedBrand]: N;
} ? F extends keyof RowCtxOf<Ctx, N> ? Step$1<IdentTy<F, RowCtxOf<Ctx, N>[F]> & {
    rowOf: N;
}, R3> : Err<`Unknown row field '${F}' on iterator '${N}'`> : Err<`inputs.${N}.${F} can only be used inside ANY, ALL, SUM, MIN or MAX`> : Fail<K2> : never : Step$1<IdentTy<N, Ctx[N]>, R2> : Err<`Unknown input '${N}'`> : Fail<K> : never : Toks extends [{
    id: "ctx";
}, ...Tok[]] ? Err<"'ctx' is reserved for future use and cannot be an input name"> : Toks extends [{
    id: infer N extends string;
}, ...Tok[]] ? Err<`Unknown identifier '${N}'; inputs are referenced as inputs.${N}`> : never;
type ParseRowPath<Toks extends Tok[], Ctx, Fn extends string> = Toks extends [
    {
        id: "inputs";
    },
    ...infer R extends Tok[]
] ? ParseKey<R> extends infer K ? [K] extends [never] ? Err<`${Fn}() takes a row field, e.g. ${Fn}(inputs.lines.qty)`> : K extends [infer N extends string, infer R2 extends Tok[]] ? N extends keyof Ctx ? IsRows<Ctx[N]> extends true ? ParseKey<R2, `inputs.${N}`> extends infer K2 ? [K2] extends [never] ? Err<`${Fn}() takes a row field, e.g. ${Fn}(inputs.${N}.qty)`> : K2 extends [infer F extends string, infer R3 extends Tok[]] ? F extends keyof RowCtxOf<Ctx, N> ? Step$1<IdentTy<F, RowCtxOf<Ctx, N>[F]>, R3> : Err<`Unknown row field '${F}' on iterator '${N}'`> : Fail<K2> : never : Err<`${Fn}() needs an iterator, field '${N}' is an input`> : Err<`Unknown iterator '${N}'`> : Fail<K> : never : Err<`${Fn}() takes a row field, e.g. ${Fn}(inputs.lines.qty)`>;
type BodyTokens<Toks extends Tok[], Depth extends 1[] = [], Acc extends Tok[] = []> = Toks extends [infer T extends Tok, ...infer R extends Tok[]] ? T extends ")" ? Depth extends [1, ...infer D extends 1[]] ? BodyTokens<R, D, [...Acc, T]> : Acc : T extends "(" ? BodyTokens<R, [1, ...Depth], [...Acc, T]> : BodyTokens<R, Depth, [...Acc, T]> : Acc;
type CollectIterators<Toks extends Tok[], Ctx, Acc = never> = Toks extends [
    {
        id: "inputs";
    },
    ...infer R extends Tok[]
] ? ParseKey<R> extends infer K ? [K] extends [never] ? CollectIterators<R, Ctx, Acc> : K extends [infer N extends string, infer R2 extends Tok[]] ? N extends keyof Ctx ? IsRows<Ctx[N]> extends true ? ParseKey<R2> extends infer K2 ? [K2] extends [never] ? CollectIterators<R2, Ctx, Acc> : K2 extends [string, infer R3 extends Tok[]] ? CollectIterators<R3, Ctx, Acc | N> : CollectIterators<R2, Ctx, Acc> : never : CollectIterators<R2, Ctx, Acc> : CollectIterators<R2, Ctx, Acc> : CollectIterators<R, Ctx, Acc> : never : Toks extends [Tok, ...infer R extends Tok[]] ? CollectIterators<R, Ctx, Acc> : Acc;
type IsUnion<U, C = U> = U extends any ? [C] extends [U] ? false : true : never;
type ParseAggregate<Fn extends AggregateFn, Toks extends Tok[], Ctx> = Ctx extends {
    readonly [scopeBrand]: "row";
} ? Err<"Aggregates are not available inside an iterator's own rules"> : Fn extends "COUNT" ? ParseFieldRef<Toks, Ctx> extends infer F ? F extends Step$1<infer T, infer R> ? T extends {
    k: "rows";
} ? R extends [")", ...infer R2 extends Tok[]] ? Step$1<TNum, R2> : Err<"COUNT() takes an iterator, e.g. COUNT(inputs.lines)"> : Err<"COUNT() takes an iterator, e.g. COUNT(inputs.lines)"> : F extends Err ? F : Err<"COUNT() takes an iterator, e.g. COUNT(inputs.lines)"> : never : Fn extends "SUM" | "MIN" | "MAX" ? ParseRowPath<Toks, Ctx, Fn> extends infer P ? P extends Step$1<infer T, infer R> ? NumericRowField<T, Fn> extends Err<infer M extends string> ? Err<M> : R extends [")", ...infer R2 extends Tok[]] ? Step$1<TNum, R2> : Err<`Expected ')' to close ${Fn}(...)`> : Fail<P> : never : CollectIterators<BodyTokens<Toks>, Ctx> extends infer Iters ? [Iters] extends [never] ? Err<`${Fn}(...) must reference a row field such as inputs.lines.qty`> : IsUnion<Iters> extends true ? Err<`${Fn}(...) may only reference one iterator`> : Iters extends string ? ParseOr<Toks, Ctx & {
    readonly [quantifiedBrand]: Iters;
}> extends infer B ? B extends Step$1<infer T, infer R> ? RequireBool<T, Fn> extends Err<infer M extends string> ? Err<M> : R extends [")", ...infer R2 extends Tok[]] ? Step$1<TBool, R2> : Err<`Expected ')' to close ${Fn}(...)`> : Fail<B> : never : never : never;
type ParsePrimary<Toks extends Tok[], Ctx> = Toks extends [
    "(",
    ...infer R extends Tok[]
] ? ParseOr<R, Ctx> extends infer E ? E extends Step$1<infer T, infer R2> ? R2 extends [")", ...infer R3 extends Tok[]] ? Step$1<T, R3> : Err<"Expected ')'"> : Fail<E> : never : Toks extends [
    {
        id: infer Fn extends AggregateFn;
    },
    "(",
    ...infer R extends Tok[]
] ? ParseAggregate<Fn, R, Ctx> : Toks extends [{
    id: "size";
}, "(", ...infer R extends Tok[]] ? ParseFieldRef<R, Ctx> extends infer F ? F extends Step$1<infer T, infer R2> ? R2 extends [")", ...infer R3 extends Tok[]] ? SizeOf<T> extends infer S ? S extends Err ? S : Step$1<S, R3> : never : Err<"size() takes one input, e.g. size(inputs.items)"> : Fail<F> : never : Toks extends [
    {
        id: infer Fn extends StringFn;
    },
    "(",
    ...infer R extends Tok[]
] ? ParseFieldRef<R, Ctx> extends infer F ? F extends Step$1<infer T, infer R2> ? R2 extends [",", {
    str: string;
}, ")", ...infer R3 extends Tok[]] ? StringFnOn<T, Fn> extends infer S ? S extends Err ? S : Step$1<S, R3> : never : Err<`${Fn}() takes a field and one quoted string, e.g. ${Fn}(inputs.code, "abc")`> : Fail<F> : never : Toks extends [{
    id: "inputs" | "ctx";
}, ...Tok[]] ? ParseFieldRef<Toks, Ctx> extends infer F ? F extends Step$1<infer T, infer R> ? R extends [".", {
    id: infer M extends string;
}, "(", ...Tok[]] ? M extends StringMethod ? Err<`Methods are not supported; write ${MethodToFn<M>}(inputs.${T extends {
    name: infer N extends string;
} ? N : "field"}, "...") instead`> : Err<`Unknown function '${M}'; text fields support STARTSWITH, ENDSWITH, CONTAINS and MATCHES`> : Step$1<T, R> : Fail<F> : never : Toks extends [{
    id: infer N extends string;
}, ...Tok[]] ? Err<`Unknown identifier '${N}'; inputs are referenced as inputs.${N}`> : Toks extends [
    {
        str: infer S extends string;
    },
    ...infer R extends Tok[]
] ? Step$1<TLit<S>, R> : Toks extends [
    {
        num: infer N extends string;
    },
    ...infer R extends Tok[]
] ? Step$1<TNum & {
    num: N;
}, R> : Toks extends ["true" | "false", ...infer R extends Tok[]] ? Step$1<TBool, R> : Toks extends ["null", ...infer R extends Tok[]] ? Step$1<TNull, R> : Toks extends [] ? Err<"Unexpected end of expression"> : Err<`Unsupported expression near '${TokText<Toks[0]>}'`>;
type ParseList<Toks extends Tok[]> = Toks extends [
    "[",
    ...infer R extends Tok[]
] ? R extends ["]", ...Tok[]] ? Err<"List must not be empty"> : ParseListItems<R, []> : Err<`'in' must be followed by a list like ["a", "b"]`>;
type ListItem$1<T> = T extends {
    str: infer S extends string;
} ? TLit<S> : T extends {
    num: infer N extends string;
} ? TNum & {
    num: N;
} : T extends "true" | "false" ? TBool : T extends "null" ? Err<"null is not allowed inside a list"> : Err<`Unsupported list item '${TokText<T>}'`>;
type ParseListItems<Toks extends Tok[], Acc extends unknown[]> = Toks extends [
    infer I,
    ...infer R extends Tok[]
] ? ListItem$1<I> extends infer Item ? Item extends Err ? Item : R extends [",", ...infer R2 extends Tok[]] ? ParseListItems<R2, [...Acc, Item]> : R extends ["]", ...infer R2 extends Tok[]] ? Step$1<[...Acc, Item], R2> : Err<"Expected ',' or ']' in list"> : never : Err<"Expected ']' to close the list">;
/** `true` when `S` is a valid boolean expression over `Ctx`, otherwise an `Err` with the message. */
type CelResult<S extends string, Ctx> = string extends S ? Err<"Visibility expression must be a string literal"> : Tokenize<S> extends infer Toks ? Toks extends Err ? Toks : Toks extends Tok[] ? ParseOr<Toks, Ctx> extends infer P ? P extends Step$1<infer T, infer Rest> ? Rest extends [] ? T extends {
    k: "bool" | "any";
} ? true : Err<"Expression must evaluate to a boolean"> : Err<`Unsupported expression near '${TokText<Rest[0]>}'`> : Fail<P> : never : never : never;
type FieldSuggestion<N extends string> = N extends `${string}${" " | "-" | "."}${string}` ? `inputs["${N}"]` : `inputs.${N}`;
type NamesStartingWith<Ctx, P extends string> = Extract<Extract<keyof Ctx, string>, `${P}${string}`>;
type CompleteReference<S extends string, Ctx, Before extends string = ""> = S extends `${infer Pre}inputs.${infer Rest}` ? ScanIdent<Rest> extends [infer P extends string, infer After extends string] ? P extends keyof Ctx ? IsRows<Ctx[P]> extends true ? CompleteRowField<After, Ctx, P, `${Before}${Pre}inputs.${P}`> : CompleteReference<After, Ctx, `${Before}${Pre}inputs.${P}`> : NamesStartingWith<Ctx, P> extends infer N ? N extends string ? `${Before}${Pre}${FieldSuggestion<N>}${After}` : never : never : never : never;
type CompleteRowField<After extends string, Ctx, Iter extends string, Before extends string> = After extends `.${infer Rest}` ? ScanIdent<Rest> extends [
    infer P extends string,
    infer After2 extends string
] ? P extends keyof RowCtxOf<Ctx, Iter> ? CompleteReference<After2, Ctx, `${Before}.${P}`> : NamesStartingWith<RowCtxOf<Ctx, Iter>, P> extends infer N ? N extends string ? `${Before}.${N}${After2}` : never : never : never : CompleteReference<After, Ctx, Before>;
type Suggestions<S extends string, Ctx> = S extends `${string}inputs.${string}` ? CompleteReference<S, Ctx> : S extends `${string}${" " | "\t" | "\n"}${string}` ? never : FieldSuggestion<Extract<keyof Ctx, string>>;
type StillTypingReference<M extends string> = M extends "Unexpected end of expression" | `Unknown identifier ${string}` | `Unknown input ${string}` | `Unknown iterator ${string}` | `Unknown row field ${string}` | 'Inputs are referenced as inputs.name or inputs["name"]' ? true : false;
/**
 * The expression itself when it is valid over `Ctx`, otherwise the error message as a string
 * literal type, so that using this as the expected type of a property makes TypeScript report
 * `Type '"inputs.pakcs >= 10"' is not assignable to type '"Unknown input 'pakcs'"'` on that
 * property. While a reference is still being typed the expected type also carries completion
 * hints (see above), so the input names are discoverable inside the string.
 */
type CelExpression<S extends string, Ctx> = CelResult<S, Ctx> extends infer R ? R extends true ? S : R extends Err<infer M extends string> ? StillTypingReference<M> extends true ? M | Exclude<Suggestions<S, Ctx>, S> : M : never : never;

/**
 * An element's `visible` property is a CEL expression over the inputs of the scope the element
 * lives in (the page, or the iterator row). The console re-evaluates it whenever the form changes;
 * the runtime evaluates it once on submit to skip validation of, and strip values from, hidden
 * elements. Inputs are referenced as `inputs.name` (or `inputs["name"]`). Both sides evaluate with
 * @marcbachmann/cel-js against a context `{ inputs: {...} }` holding every input of the scope (null
 * when the form has no value), treating an evaluation error as "hidden".
 */
type VisibilityExpression = string;
type InputNames<T extends UIElements> = Extract<T[number], InputElementResponse<string, any, any>>["name"];
/** Everything a rule can target: inputs and iterators by name, display elements by `key`. */
type VisibilityTargets<T extends UIElements> = InputNames<T> | Extract<T[number], IteratorElementResponse<string, any, any>>["name"] | Extract<T[number], DisplayElementResponse<string>>["key"];
type IteratorNames<T extends UIElements> = Extract<T[number], IteratorElementResponse<string, any, any>>["name"];
/**
 * The members of a scope as `{ name: valueType }`, the context a CEL string is checked against.
 * Inputs map to their value type; iterators map to a branded `Rows` of their row context so
 * aggregates can type their row fields. The scope brand says whether aggregates are allowed.
 */
type CelCtx<T extends UIElements, Scope extends ScopeKind = "page"> = {
    [K in InputNames<T>]: Extract<T[number], InputElementResponse<K, any, any>>["valueType"];
} & {
    [K in IteratorNames<T>]: Rows<IteratorRowCtx<T, K>>;
} & {
    readonly [scopeBrand]: Scope;
};
type IteratorRowCtx<T extends UIElements, K extends string> = Extract<T[number], IteratorElementResponse<K, any, any>> extends IteratorElementResponse<K, infer E extends UIElements, any> ? CelCtx<E, "row"> : never;
/**
 * The `visibility` option of a page or iterator: one CEL expression per target element. `V` is
 * the inferred (const) type of the object written by the author, so each string literal can be
 * checked by the type-level CEL parser and replaced by its error message when invalid; the error
 * then lands on that property. "Is set" is spelled `inputs.x != null && inputs.x != ""` for text
 * fields and `inputs.x != null && size(inputs.x) > 0` for lists.
 */
type VisibilityInput<T extends UIElements, V, Scope extends ScopeKind = "page"> = {
    [K in keyof V]: K extends VisibilityTargets<T> ? V[K] extends string ? CelExpression<V[K], CelCtx<T, Scope>> : `Visibility rules are CEL strings, e.g. "inputs.hasDiscount == true"` : `Unknown visibility target '${K & string}'`;
};

type ElementDataType$6 = string | number | boolean | Date;
type UiElementSelectOne = <const TValue extends ElementDataType$6, N extends string, O extends boolean = false>(name: N, options?: BaseInputConfig<TValue, O> & {
    options: ({
        label: string;
        value: TValue;
    } | TValue)[];
}) => InputElementResponse<N, O extends true ? TValue | undefined : TValue>;
interface UiElementSelectOneApiResponse extends BaseUiInputResponse<"ui.select.one", ElementDataType$6> {
    options: ({
        label: string;
        value: ElementDataType$6;
    } | ElementDataType$6)[];
}

type ElementDataType$5 = string;
type UiElementInputText = InputElement<ElementDataType$5, {
    placeholder?: string;
    multiline?: boolean;
    maxLength?: number;
    minLength?: number;
}>;
interface UiElementInputTextApiResponse extends BaseUiInputResponse<"ui.input.text", ElementDataType$5> {
    placeholder?: string;
    multiline?: boolean;
    maxLength?: number;
    minLength?: number;
}

type ElementDataType$4 = number;
type UiElementInputNumber = InputElement<ElementDataType$4, {
    placeholder?: string;
    min?: number;
    max?: number;
}>;
interface UiElementInputNumberApiResponse extends BaseUiInputResponse<"ui.input.number", ElementDataType$4> {
    placeholder?: string;
    min?: number;
    max?: number;
}

type ElementDataType$3 = boolean;
type UiElementInputBoolean = InputElement<ElementDataType$3, {
    mode?: "checkbox" | "switch";
}>;
interface UiElementInputBooleanApiResponse extends BaseUiInputResponse<"ui.input.boolean", ElementDataType$3> {
    mode: "checkbox" | "switch";
}

type ElementDataType$2 = string;
/**
 * Defines what type of datepicker should we use.
 * @default "dateTime"
 */
type DatePickerMode = 
/** Pick both a date and a time */
"dateTime"
/** Pick only a date */
 | "date";
type UiElementInputDatePicker = InputElement<ElementDataType$2, {
    mode?: DatePickerMode;
    /** Allows selecting only dates/datetimes past this given date. */
    min?: string;
    /** Allows selecting only dates/datetimes before this given date. */
    max?: string;
}>;
interface UiElementInputDatePickerApiResponse extends BaseUiInputResponse<"ui.input.datePicker", ElementDataType$2> {
    mode?: DatePickerMode;
    min?: string;
    max?: string;
}

type ElementDataType$1 = Partial<FileDbRecord>;
type UiElementInputFile = InputElement<ElementDataType$1, {}, File>;
interface UiElementInputFileApiResponse extends BaseUiInputResponse<"ui.input.file", ElementDataType$1> {
}

/**
 * Data posted by the client for a single image capture entry.
 * `file` carries the upload metadata (the bytes go via the presigned URL).
 */
type ImageCaptureValue = {
    file: Partial<FileDbRecord>;
    caption?: string;
};
/**
 * Hydrated entry handed to the flow function: `file` becomes a real File
 * instance (via transformRichDataTypes).
 */
type ImageCaptureResult = {
    file: File;
    caption?: string;
};
type ImageCaptureMode = "single" | "multi";
type ImageCaptureCaptionMode = "disabled" | "optional" | "required";
type ImageCaptureValueFor<M> = M extends "multi" ? ImageCaptureValue[] : ImageCaptureValue;
type ImageCaptureResultFor<M> = M extends "multi" ? ImageCaptureResult[] : ImageCaptureResult;
type SharedOptions = {
    /** Controls whether captions are disabled, optional, or required. Defaults to "optional". */
    caption?: ImageCaptureCaptionMode;
};
type ImageCaptureOptions<M extends ImageCaptureMode> = SharedOptions & {
    /** The mode of the image capture input. Defaults to "single". */
    mode?: M;
} & (M extends "multi" ? {
    /** Maximum number of photos the user can capture. */
    max?: number;
    /** Minimum number of photos the user must capture. */
    min?: number;
} : {});
type UiElementInputImageCapture = <N extends string, const M extends ImageCaptureMode = "single">(name: N, options?: BaseInputConfig<ImageCaptureValueFor<M>> & ImageCaptureOptions<M>) => InputElementResponse<N, ImageCaptureValueFor<M>, ImageCaptureResultFor<M>>;
interface UiElementInputImageCaptureApiResponse extends BaseUiInputResponse<"ui.input.imageCapture", ImageCaptureValue | ImageCaptureValue[]> {
    mode: ImageCaptureMode;
    caption: ImageCaptureCaptionMode;
    /** Multi mode only: maximum number of photos. */
    max?: number;
    /** Multi mode only: minimum number of photos. */
    min?: number;
}

type ElementDataType = {
    svg: string;
    signedAt: string;
};
declare class Signature {
    readonly svg: string;
    readonly signedAt: string;
    constructor(data: ElementDataType);
    toPngDataURL(): Promise<string>;
}
type UiElementInputSignature = InputElement<ElementDataType, {}, Signature>;
interface UiElementInputSignatureApiResponse extends BaseUiInputResponse<"ui.input.signature", ElementDataType> {
}

type UiElementMarkdown = DisplayElement<{
    content: string;
}>;
interface UiElementMarkdownApiResponse extends BaseUiDisplayResponse<"ui.display.markdown"> {
    content: string;
}

type TableData<T extends Record<string, any>> = {
    data: T[];
    columns?: Array<Extract<keyof T, string>>;
};
type UiElementTable = <const T extends Record<string, any>, K extends string = never>(options: TableData<T> & DisplayElementConfig<K>) => DisplayElementResponse<K>;
type TableColumn = {
    name: string;
    index: number;
};
interface UiElementTableApiResponse extends BaseUiDisplayResponse<"ui.display.table"> {
    data: any[];
    columns: TableColumn[];
}

type UiElementDivider = DisplayElement<{}>;
interface UiElementDividerApiResponse extends BaseUiDisplayResponse<"ui.display.divider"> {
}

type PageOptions<C extends FlowConfig, A extends PageActions[], T extends UIElements, V> = {
    stage?: ExtractStageKeys<C>;
    title?: string;
    description?: string;
    content: T;
    /**
     * Show elements only while a CEL expression over the page's other inputs holds, e.g.
     * `{ discountCode: "inputs.hasDiscount == true" }`. Keys are input and iterator names and display
     * element `key`s. Expressions are checked against the page's inputs as you type. Hidden inputs
     * are not validated and are absent from the result.
     */
    visibility?: VisibilityInput<T, V>;
    validate?: ValidateFn<ExtractFormData<T>>;
    actions?: A;
    allowBack?: boolean;
    fullWidth?: boolean;
};
type UiPage<C extends FlowConfig> = <T extends UIElements, const A extends PageActions[] = [], const V = {}>(name: string, options: PageOptions<C, A, T, V>) => Promise<A["length"] extends 0 ? ExtractFormData<T, keyof V> : {
    data: ExtractFormData<T, keyof V>;
    action: ActionValue<A[number]>;
}>;
type PageActions = string | PageActionConfig;
type PageActionConfig = {
    label: string;
    value: string;
    mode?: "primary" | "secondary" | "destructive";
    /**
     * Keyboard shortcut for this action.
     *
     * @example
     * // Single key
     * hotkey: "1"
     * hotkey: "enter"
     * hotkey: "space"
     * hotkey: "F1"
     *
     *
     * // With modifier:
     * // shift, alt + mod (cmd on macOS, ctrl on Windows/Linux)
     *
     * hotkey: "mod+s"           // cmd+s on macOS, ctrl+s on Windows/Linux
     * hotkey: "mod+shift+enter" // cmd+shift+enter on macOS, ctrl+shift+enter on Windows/Linux
     *
     * // With behavior control
     * hotkey: {
     *   key: "mod+enter",
     *   behaviour: "includeForms"  // Trigger even when focused on form elements
     * }
     */
    hotkey?: string | HotkeyConfig;
};
type HotkeyConfig = {
    key: string;
    /** If the hotkey should be triggered when the user is on a form element or not
     *
     * @default "excludeForms"
     */
    behaviour?: "includeForms" | "excludeForms";
};
type ActionValue<T> = T extends string ? T : T extends {
    value: infer V;
} ? V : never;
type ExtractFormData<T extends UIElements, Hidden extends PropertyKey = never> = {
    [K in Extract<T[number], InputElementResponse<string, any>>["name"]]: Extract<T[number], InputElementResponse<K, any>>["returnType"] | (K extends Hidden ? undefined : never);
} & {
    [K in Extract<T[number], IteratorElementResponse<string, any, any>>["name"]]: Extract<T[number], IteratorElementResponse<K, any, any>>["contentData"] | (K extends Hidden ? undefined : never);
};

type UiElementImage = DisplayElement<{
    url: string;
    alt?: string;
    size?: "thumbnail" | "small" | "medium" | "large" | "full";
    caption?: string;
}>;
interface UiElementImageApiResponse extends BaseUiDisplayResponse<"ui.display.image"> {
    url: string;
    alt?: string;
    size?: "thumbnail" | "small" | "medium" | "large" | "full";
    caption?: string;
}

type BannerMode = "info" | "warning" | "error" | "success";
type UiElementBanner = DisplayElement<{
    title: string;
    description: string;
    mode?: BannerMode;
}>;
interface UiElementBannerApiResponse extends BaseUiDisplayResponse<"ui.display.banner"> {
    title: string;
    description: string;
    mode: BannerMode;
}

type UiElementHeader = DisplayElement<{
    /**
     * The visual level of the header.
     *
     * @default 2
     */
    level?: 1 | 2 | 3;
    /**
     * The title of the header.
     */
    title?: string;
    /**
     * The description of the header.
     */
    description?: string;
}>;
interface UiElementHeaderApiResponse extends BaseUiDisplayResponse<"ui.display.header"> {
    level: number;
    title: string;
    description: string;
}

type UiElementCode = DisplayElement<{
    code: string;
    language?: string;
}>;
interface UiElementCodeApiResponse extends BaseUiDisplayResponse<"ui.display.code"> {
    code: string;
    language?: string;
}

type ImageConfig$1 = {
    url: string;
    alt?: string;
    aspectRatio?: number;
    fit?: "cover" | "contain";
};
type GridItem = {
    title?: string;
    description?: string;
    image?: ImageConfig$1;
};
type GridOptions<T> = {
    data: T[];
    render: (data: T) => GridItem;
};
type UiElementGrid = <T extends any, K extends string = never>(options: GridOptions<T> & DisplayElementConfig<K>) => DisplayElementResponse<K>;
interface UiElementGridApiResponse extends BaseUiDisplayResponse<"ui.display.grid"> {
    data: GridItem[];
}

type ImageConfig = {
    url: string;
    alt?: string;
    fit?: "cover" | "contain";
};

type ListItem = {
    title?: string;
    description?: string;
    image?: ImageConfig;
};
type ListOptions<T> = {
    data: T[];
    render: (data: T) => ListItem;
};
type UiElementList = <T extends any, K extends string = never>(options: ListOptions<T> & DisplayElementConfig<K>) => DisplayElementResponse<K>;
interface UiElementListApiResponse extends BaseUiDisplayResponse<"ui.display.list"> {
    data: ListItem[];
}

type KeyValueMode = "list" | "grid" | "card";
type KeyValueData = {
    key: string;
    value: string | number | Date | boolean;
};
type UiElementKeyValue = DisplayElement<{
    data: KeyValueData[];
    mode?: KeyValueMode;
}>;
interface UiElementKeyValueApiResponse extends BaseUiDisplayResponse<"ui.display.keyValue"> {
    data: KeyValueData[];
    mode: KeyValueMode;
}

declare const toolRefBrand: unique symbol;
/**
 * A reference to a console tool and the inputs it opens with. This is what a
 * generated `tools.<name>(...)` accessor returns; it carries nothing about how
 * or where it is used, so the same value can point at a tool from a flow's
 * completion redirect today and from other surfaces later.
 */
type ToolRef<K extends string, In> = {
    readonly [toolRefBrand]: true;
    readonly toolId: K;
} & RedirectInputs<In>;
/**
 * A generated `tools.<name>` accessor: takes the tool's inputs and returns a
 * ToolRef. The inputs can be omitted only when every input of the tool is
 * optional.
 */
type ToolAccessor<K extends string, In> = AllOptional<In> extends true ? (inputs?: In) => ToolRef<K, In> : (inputs: In) => ToolRef<K, In>;
/**
 * Builds the SDK's `tools` object from `{ accessorName: toolId }`, which the
 * generated SDK passes in. Each accessor only pairs the baked-in tool id with
 * the inputs it is given.
 */
declare function createToolsAPI<M extends Record<string, string>>(ids: M): {
    [N in keyof M]: (inputs?: unknown) => ToolRef<M[N], unknown>;
};

type AllOptional<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
}[keyof T] extends never ? true : false;
type RestartConfig = {
    /**
     * If auto, the flow will restart automatically with a notification instead of a completion screen.
     * If manual, a button will be shown on the completion screen.
     * Default is manual.
     * */
    mode?: "manual" | "auto";
    buttonLabel?: string;
};
type AnyToolInputs = Record<string, any>;
type RedirectInputs<In> = AllOptional<In> extends true ? {
    inputs?: In;
} : {
    inputs: In;
};
type ToolRefOf<T> = {
    [K in keyof T & string]: ToolRef<K, T[K]>;
}[keyof T & string];
/**
 * Where to send the user once the flow completes: a console tool reference
 * from the generated `tools` accessors, on its own (rendered as the completion
 * screen's primary button, labelled with the tool's name) or wrapped with the
 * flow-specific presentation options.
 */
type RedirectConfig<T> = RedirectConfigFor<ToolRefOf<T>>;
type RedirectConfigFor<R> = [R] extends [never] ? never : (R & {
    tool?: never;
    label?: never;
    autoRedirect?: never;
}) | {
    /** The tool to open, e.g. `tools.getOrder({ id })`. */
    tool: R;
    /** Button label. Defaults to the target tool's name. */
    label?: string;
    /**
     * Navigate to the tool as soon as the flow completes instead of
     * showing the completion screen with a button. Title and description
     * are shown as a notification; `content` and `allowRestart` are not
     * shown.
     */
    autoRedirect?: boolean;
};
type CompleteOptions<C extends FlowConfig, I, T = AnyToolInputs> = {
    stage?: ExtractStageKeys<C>;
    title?: string;
    description?: string;
    /** Automatically close the flow once complete.
     * Title and description will be shown in a notification if provided.
     * If set, you cannot return content as this will not be shown. */
    autoClose?: boolean;
    fullWidth?: boolean;
    /** Restart the flow once complete.
     * Title and description will be shown in a notification if provided.
     * If set, the flow will be restarted with the inputs provided.
     * If set, you cannot return content as this will not be shown. */
    allowRestart?: false | ([I] extends [never] ? boolean | RestartConfig : RestartConfig & (AllOptional<I> extends true ? {
        inputs?: I;
    } : {
        inputs: I;
    }));
    data?: any;
} & ({
    autoClose: true;
    content?: never;
    redirect?: never;
} | {
    autoClose?: false;
    content?: DisplayElementResponse<any>[];
    fullWidth?: boolean;
    /** Send the user to another console tool once the flow completes.
     * Shown as the primary button on the completion screen, so it cannot be
     * combined with autoClose or allowRestart in "auto" mode. */
    redirect?: RedirectConfig<T>;
});
type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
type Complete<C extends FlowConfig, I, T = AnyToolInputs> = <D = undefined>(options: DistributiveOmit<CompleteOptions<C, I, T>, "data"> & {
    data?: D;
}) => DistributiveOmit<CompleteOptions<C, I>, "data"> & {
    data?: D;
    __type: "ui.complete";
};

type SelectMode = "single" | "multi";
type UiElementSelectTable = <const T extends Record<string, any>, N extends string, const M extends SelectMode = "multi", const O extends boolean = false>(name: N, options: TableOptions<T, O, M>) => InputElementResponse<N, M extends "single" ? (O extends true ? T | undefined : T) : T[]>;
type TableOptions<T extends Record<string, any>, O extends boolean, M extends SelectMode> = Omit<BaseInputConfig<M extends "single" ? (O extends true ? T | undefined : T) : T[], O>, "defaultValue" | "label"> & TableData<T> & ({
    mode?: M;
} | {
    mode: "multi";
    max?: number;
    min?: number;
});
interface UiElementSelectTableApiResponse extends Omit<BaseUiInputResponse<"ui.select.table", any>, "defaultValue" | "label"> {
    data: Record<string, any>[];
    columns: TableColumn[];
    mode: SelectMode;
}

declare const NUMBER_STYLES: {
    readonly decimal: "DECIMAL";
    readonly raw: "RAW";
    readonly percent: "PERCENTAGE";
    readonly currency: "CURRENCY";
    readonly unit: "UNIT";
};
declare const SIGN_DISPLAYS: {
    readonly auto: "AUTO";
    readonly exceptZero: "EXCEPT_ZERO";
    readonly always: "ALWAYS";
    readonly never: "NEVER";
};
/**
 * How numbers are coloured, chosen by `mode`. `sign` colours non-zero numbers by their sign; zero is
 * never coloured.
 */
type ColumnNumberColor = {
    mode: "sign";
    positive: "green";
    negative: "red";
} | {
    mode: "sign";
    positive: "red";
    negative: "green";
};
type ColumnNumberFormat = {
    /** As `Intl.NumberFormat`'s `style`, plus `raw` for the unformatted number. Defaults to `decimal`. */
    style?: keyof typeof NUMBER_STYLES;
    /** ISO 4217 code, used by the `currency` style. */
    currency?: string;
    /** Unit identifier used by the `unit` style, e.g. `kilogram` or `meter-per-second`. */
    unit?: string;
    /** As `Intl.NumberFormat`'s `signDisplay`. */
    signDisplay?: keyof typeof SIGN_DISPLAYS;
    color?: ColumnNumberColor;
    /** Hidden by default; revealed on hover. */
    sensitive?: boolean;
    /** Locale code; detected from the browser when omitted. */
    locale?: string;
    prefix?: string;
    suffix?: string;
};
type ColumnTextFormat = {
    prefix?: string;
    suffix?: string;
    color?: string;
    /** Hidden by default; revealed on hover. */
    sensitive?: boolean;
};
/** How a single value is displayed: `label` replaces the value's text. */
type ColumnValueFormat = {
    label?: string;
    color?: string;
};
type ColumnBooleanFormat = {
    true?: ColumnValueFormat;
    false?: ColumnValueFormat;
};
type FormatKind = {
    number: ColumnNumberFormat;
    text: ColumnTextFormat;
    boolean: ColumnBooleanFormat;
    /** Formats keyed by cell value, e.g. `{ late: { label: "Late", color: "red" } }`. */
    values: Record<string, ColumnValueFormat>;
};
/** How a column's cells are displayed. Set exactly one of `number`, `text`, `boolean` or `values`. */
type ColumnFormat = {
    [K in keyof FormatKind]: {
        [P in K]: FormatKind[K];
    } & {
        [P in Exclude<keyof FormatKind, K>]?: never;
    };
}[keyof FormatKind];
type ColumnFormatApiResponse = {
    type: "NUMBER" | "STRING" | "BOOL" | "ENUM";
    numberConfig?: {
        mode?: (typeof NUMBER_STYLES)[keyof typeof NUMBER_STYLES];
        currencyCode?: string;
        unitCode?: string;
        sensitive?: boolean;
        locale?: string;
        prefix?: string;
        suffix?: string;
        colourise?: "NORMAL" | "INVERTED";
        signDisplay?: (typeof SIGN_DISPLAYS)[keyof typeof SIGN_DISPLAYS];
    };
    stringConfig?: {
        prefix?: string;
        suffix?: string;
        sensitive?: boolean;
        textColour?: string;
    };
    boolConfig?: {
        positiveColour?: string;
        positiveValue?: string;
        negativeColour?: string;
        negativeValue?: string;
    };
    enumConfig?: {
        values: {
            value: string;
            displayValue?: string;
            colour?: string;
        }[];
    };
};

type UiElementInputDataGrid = <N extends string, T extends Record<string, any>, const Cols extends Extract<keyof T, string>[], C extends ColumnConfig<Cols>[] | undefined = undefined>(name: N, options: DataGridOptions<T, C, Cols>) => InputElementResponse<N, C extends ColumnConfig<Cols>[] ? {
    [K in C[number] as K["key"]]: MapDataType<K["type"], T[K["key"]]>;
}[] : T[]>;
type MapDataType<U, Fallback> = U extends "text" ? string : U extends "number" ? number : U extends "boolean" ? boolean : U extends "id" ? string : U extends "select" ? string : U extends "lookup" ? string : U extends "hidden" ? Fallback : Fallback;
/** An option offered by a `select` or `lookup` column. `value` is what is stored in the cell. */
type DataGridOption = {
    value: string;
    label: string;
    description?: string;
};
/**
 * How a column's footer cell is populated. `sum` and `count` are aggregated in the browser from
 * the current rows; `computed` is supplied by the flow through an aggregate callback.
 */
type DataGridSummary = "sum" | "count" | "computed";
/**
 * One totals entry. Strings render verbatim, numbers are formatted by the client. `label` is only
 * used by the grid's `summary` block; the column footer ignores it.
 */
type DataGridTotal = {
    value: number | string;
    label?: string;
};
/**
 * Totals returned by a grid's `totals` function, keyed by name. Keys matching a `summary: "computed"`
 * column fill that column's footer cell; any other keys (e.g. `vat`, `grandTotal`) are rendered only
 * by the grid's `summary` block. Key order is not preserved over the wire; use `summary.items` to
 * control display order.
 */
type DataGridTotals = {
    [key: string]: DataGridTotal;
};
/** One row of a grid's summary block. */
type DataGridSummaryItem = {
    /** The totals key whose live value this row shows. */
    key?: string;
    /** Row label. Defaults to the live total's label, then to `key`. */
    label?: string;
    /** Static value, or the value shown until the first live total arrives. Strings render verbatim. */
    value?: number | string;
    /** Marks a headline row (e.g. the grand total); the client renders it emphasised. */
    important?: boolean;
};
/**
 * A read-only block rendered beneath the grid, fed by the grid's `totals` function. Keyed items
 * show that key's live total; label-only items are static. Without `items`, every total is shown
 * in alphabetical key order.
 */
type DataGridSummaryBlock = {
    title?: string;
    /** Rows to render, in order. */
    items?: DataGridSummaryItem[];
};
/** Configuration for a column of type `lookup`. */
type DataGridLookupConfig = {
    /**
     * Resolves the options offered for the given search query. Invoked through the element's
     * `onLookup` callback as the user types; `query` may be an empty string.
     */
    search: (args: {
        query: string;
    }) => DataGridOption[] | Promise<DataGridOption[]>;
    /**
     * Display labels for ids already present in `data`, keyed by id. Labels are not derived
     * automatically, so build this from the same query that produced the rows.
     */
    labels?: Record<string, string>;
    placeholder?: string;
};
type ColumnConfig<Cols extends string[]> = {
    key: Cols[number];
    label?: string;
    /** Inferred as `select` when `options` is set and `lookup` when `lookup` is set. */
    type?: DataGridDataTypes;
    editable?: boolean;
    /** Seed value for rows the user adds. */
    defaultValue?: string | number | boolean | null;
    /** Static options for a `select` column. */
    options?: DataGridOption[];
    lookup?: DataGridLookupConfig;
    /** Renders a totals footer for this column. */
    summary?: DataGridSummary;
    /** How the column's read-only cells are displayed, as in list-view datagrids (e.g. colourising numbers by sign). */
    format?: ColumnFormat;
};
/**
 * Computes the grid's totals from its current rows (see `DataGridTotals`). Invoked through the
 * element's `onTotals` callback when the page opens and, debounced, after edits, so it should be
 * cheap and idempotent.
 */
type DataGridTotalsFn<T> = (rows: T[]) => DataGridTotals | Promise<DataGridTotals>;
type DataGridOptions<T extends Record<string, any>, C, Cols extends string[] = Extract<keyof T, string>[]> = Omit<BaseInputConfig<T[]>, "defaultValue" | "label" | "optional" | "disabled"> & {
    data: T[];
    columns?: C | ColumnConfig<Cols>[];
    allowAddRows?: boolean;
    allowDeleteRows?: boolean;
    totals?: DataGridTotalsFn<T>;
    /** Renders a summary block beneath the grid. Live (keyed) rows require `totals`. */
    summary?: DataGridSummaryBlock;
};
interface UiElementInputDataGridApiResponse extends Omit<BaseUiInputResponse<"ui.input.dataGrid", any>, "defaultValue" | "label" | "optional" | "disabled"> {
    data: any[];
    columns: DataGridColumn[];
    allowAddRows: boolean;
    allowDeleteRows: boolean;
    summary?: DataGridSummaryBlock;
}
type DataGridDataTypes = "text" | "number" | "boolean" | "id" | "hidden" | "select" | "lookup";
type DataGridColumn = {
    key: string;
    label: string;
    index: number;
    type: DataGridDataTypes;
    editable: boolean;
    defaultValue?: string | number | boolean | null;
    options?: DataGridOption[];
    lookup?: {
        labels?: {
            [id: string]: string;
        };
        placeholder?: string;
    };
    summary?: DataGridSummary;
    format?: ColumnFormatApiResponse;
};

type UiElementIterator = <N extends string, T extends UIElements, const V = {}>(name: N, options: {
    content: T;
    /** Visibility rules for the row's elements, evaluated against the same row's inputs. */
    visibility?: VisibilityInput<T, V, "row">;
    validate?: ValidateFn<ExtractFormData<T>[]>;
    max?: number;
    min?: number;
}) => IteratorElementResponse<N, T, ExtractFormData<T, keyof V>[]>;
interface UiElementIteratorApiResponse extends BaseUiDisplayResponse<"ui.iterator"> {
    name: string;
    content: UiElementApiResponses;
    max?: number;
    min?: number;
    validationError?: string;
    contentValidationErrors?: Array<{
        index: number;
        name: string;
        validationError: string;
    }>;
}

type UiElementPrint<H extends NullableHardware> = DisplayElementWithRequiredConfig<{
    jobs: PrintData<H>[] | PrintData<H>;
    title?: string;
    description?: string;
    /** If true, the jobs will be automatically printed. */
    autoPrint?: boolean;
    /** If true, the step will continue after the jobs are complete (pending validation). */
    autoContinue?: boolean;
    /** Control whether users can reprint jobs
     * @default true
     */
    allowReprint?: boolean;
}>;
type PrintData<H extends NullableHardware> = {
    /** The name of the print job. */
    name?: string;
    /** The printer to use for the print job. Printers are defined in keelconfig.yaml. */
    printer?: H extends Hardware ? H["printers"][number]["name"] : never;
} & (PrintDataZpl | PrintDataRawPdf);
type PrintDataZpl = {
    type: "zpl";
} & ({
    data: string | string[];
    url?: never;
} | {
    data?: never;
    url: string;
});
type PrintDataRawPdf = {
    type: "rawPdf";
    url: string;
    data?: never;
    /** The DPI of the PDF
     * @default 300
     */
    dpi?: number;
    /** The width of the page in dots.
     * e.g. 4" at 300 dpi is 1200 dots.
     * @default 1200
     */
    pageWidth?: number;
    /** The height of the page in dots.
     * e.g. 6" at 300 dpi is 1800 dots.
     * @default 1800
     */
    pageHeight?: number;
};
interface UiElementPrintApiResponse extends BaseUiDisplayResponse<"ui.interactive.print"> {
    title?: string;
    description?: string;
    data: {
        type: "zpl" | "rawPdf";
        name?: string;
        data?: string[];
        url?: string;
        printer?: string;
        dpi?: number;
        pageWidth?: number;
        pageHeight?: number;
    }[];
    autoPrint: boolean;
    autoContinue: boolean;
    allowReprint: boolean;
}

type UiElementPickList = <N extends string, T extends Record<string, any>, const M extends PickListInputModes = {
    scanner: true;
    manual: true;
}>(name: N, options: PickListOptions<M, T>) => InputElementResponse<N, {
    items: PickListResponseItem[];
}>;
type PickListResponseItem = {
    id: string;
    quantity: number;
    targetQuantity: number;
    scannedBarcodes?: string[];
};
type PickListItem = {
    id: string;
    targetQuantity: number;
    title?: string;
    description?: string;
    image?: ImageConfig;
    barcodes?: string[];
};
/**
 * Defines how duplicate scans should be handled.
 * @default "increaseQuantity"
 */
type ScanDuplicateMode$1 = 
/** Increase quantity when duplicates are scanned */
"increaseQuantity"
/** Reject duplicate scans with an error message */
 | "rejectDuplicates";
/**
 * Defines how picking items should be handled. By default, all modes are enabled.
 */
type PickListInputModes = {
    /** Picking items can be done by scanning barcodes */
    scanner: boolean;
    /** Picking items can be done by using the add/remove buttons */
    manual: boolean;
};
type PickListOptions<M extends PickListInputModes, T> = {
    data: T[];
    render: (data: T) => PickListItem;
    supportedInputs?: M;
    validate?: ValidateFn<{
        items: PickListResponseItem[];
    }>;
    duplicateHandling?: ScanDuplicateMode$1 | undefined;
    /** If true, the step will continue after all items reach the target quantity (pending validation)
     * Only applied for scanner inputs.
     */
    autoContinue?: boolean;
};
interface UiElementPickListApiResponse extends BaseUiMinimalInputResponse<"ui.interactive.pickList"> {
    data: PickListItem[];
    supportedInputs: PickListInputModes;
    duplicateHandling: ScanDuplicateMode$1 | undefined;
    autoContinue: boolean;
}

type UiElementScan = <N extends string, const M extends scanMode = "single", const D extends ScanDuplicateMode = "none", R = string | null>(name: N, options?: ScanOptions<M, D, R>) => InputElementResponse<N, M extends "single" ? string : ScanResponseItem<D>[]>;
type ScanResponseItem<D> = D extends "trackQuantity" ? {
    value: string;
    quantity: number;
} : string;
/**
 * Defines how duplicate scans should be handled.
 * @default "none"
 */
type ScanDuplicateMode = 
/** No duplicate handling - all scans are accepted as separate entries */
"none"
/** Track quantity when duplicates are scanned */
 | "trackQuantity"
/** Reject duplicate scans with an error message */
 | "rejectDuplicates";
type scanMode = "single" | "multi";
type ScanOptions<M, D, R = string | null> = {
    /** The title of the input block
     * @default "Scan {unit plural | 'items'}"
     */
    title?: string;
    description?: string;
    /** The singular unit of the item being scanned. E.g. "box", "bottle", "product" etc */
    unit?: string;
    /** The mode of the scan input
     * @default "single"
     */
    mode: M | scanMode;
    validate?: ValidateFn<ScanResponseItem<D>>;
    /** Converts a scanned value into the value this element should return.
     * Use it to turn a raw barcode into the data your flow actually wants —
     * e.g. a product name, an internal ID, or a full record. Defaults to
     * `string | null`; return a richer JSON-serializable shape to let
     * TypeScript infer it.
     */
    lookup?: (value: string) => R | Promise<R>;
} & (M extends "multi" ? {
    max?: number;
    min?: number;
    duplicateHandling?: D | ScanDuplicateMode;
} : {
    /** If true, the step will continue after a scan (pending validation).
     * @default false
     */
    autoContinue?: boolean;
});
interface UiElementInputScanApiResponse extends BaseUiMinimalInputResponse<"ui.input.scan"> {
    mode: "single" | "multi";
    title?: string;
    description?: string;
    unit?: string;
    max?: number;
    min?: number;
    duplicateHandling: ScanDuplicateMode;
    autoContinue: boolean;
}

type UiElementFile = DisplayElementWithRequiredConfig<{
    title?: string;
    file: File;
}>;
interface UiElementFileApiResponse extends BaseUiDisplayResponse<"ui.display.file"> {
    title: string;
    file?: FileDbRecord & {
        url: string;
    };
}

/** One row of a summary block. */
type SummaryItem = {
    label: string;
    /** Strings render verbatim, numbers are formatted by the client. */
    value: number | string;
    /** Marks a headline row (e.g. the grand total); the client renders it emphasised. */
    important?: boolean;
};
type UiElementSummary = DisplayElementWithRequiredConfig<{
    title?: string;
    /** Rows to render, in order. */
    items: SummaryItem[];
}>;
interface UiElementSummaryApiResponse extends BaseUiDisplayResponse<"ui.display.summary"> {
    title?: string;
    items: SummaryItem[];
}

/** The axis granularity the timeline opens at. Unset falls back to weeks on the client. */
type TimelineGranularity = "hours" | "days" | "weeks" | "months";
/** Items sharing a row key render as bars on a single row (e.g. the phases of one initiative). */
type TimelineRow = {
    key: string;
    /** The row label; `title` then labels each bar. */
    title?: string;
};
/** What `render` returns for one record. Dates may be `Date` objects or ISO 8601 strings. */
type TimelineItemInput = {
    /** The bar label, and the row label when there is no `row`. */
    title: string;
    start: Date | string;
    /** Without an end the item is a point event one period wide. */
    end?: Date | string;
    /** A category label; the client assigns one colour per distinct value. */
    color?: string;
    /** 0–100, rendered as the bar's fill. */
    progress?: number;
    /** Items nest under a collapsible section per distinct value. */
    group?: string;
    row?: TimelineRow;
};
/** The item as sent over the API: dates are ISO 8601 strings. */
type TimelineItem = Omit<TimelineItemInput, "start" | "end"> & {
    start: string;
    end?: string;
};
type TimelineOptions<T> = {
    data: T[];
    render: (data: T) => TimelineItemInput;
    defaultGranularity?: TimelineGranularity;
};
type UiElementTimeline = <T extends any, K extends string = never>(options: TimelineOptions<T> & DisplayElementConfig<K>) => DisplayElementResponse<K>;
interface UiElementTimelineApiResponse extends BaseUiDisplayResponse<"ui.display.timeline"> {
    data: TimelineItem[];
    defaultGranularity?: TimelineGranularity;
}

interface UI<C extends FlowConfig, H extends NullableHardware> {
    page: UiPage<C>;
    display: UiDisplayElements;
    inputs: UiInputsElements;
    select: UiSelectElements;
    iterator: UiElementIterator;
    interactive: UiInteractiveElements<H>;
}
type UiInputsElements = {
    text: UiElementInputText;
    number: UiElementInputNumber;
    boolean: UiElementInputBoolean;
    dataGrid: UiElementInputDataGrid;
    datePicker: UiElementInputDatePicker;
    scan: UiElementScan;
    file: UiElementInputFile;
    imageCapture: UiElementInputImageCapture;
    signature: UiElementInputSignature;
};
type UiSelectElements = {
    one: UiElementSelectOne;
    table: UiElementSelectTable;
};
type UiDisplayElements = {
    divider: UiElementDivider;
    markdown: UiElementMarkdown;
    header: UiElementHeader;
    banner: UiElementBanner;
    image: UiElementImage;
    code: UiElementCode;
    grid: UiElementGrid;
    list: UiElementList;
    table: UiElementTable;
    keyValue: UiElementKeyValue;
    file: UiElementFile;
    summary: UiElementSummary;
    timeline: UiElementTimeline;
};
type UiInteractiveElements<H extends NullableHardware> = {
    print: UiElementPrint<H>;
    pickList: UiElementPickList;
};
type InputElement<TValueType, TConfig extends any = never, TReturnType = TValueType> = <N extends string>(name: N, options?: BaseInputConfig<TValueType> & TConfig) => InputElementResponse<N, TValueType, TReturnType>;
type DisplayElementConfig<K extends string> = {
    key?: K;
};
type DisplayElement<TConfig extends any = never> = <K extends string = never>(options?: TConfig & DisplayElementConfig<K>) => DisplayElementResponse<K>;
type DisplayElementWithRequiredConfig<TConfig extends any = never> = <K extends string = never>(options: TConfig & DisplayElementConfig<K>) => DisplayElementResponse<K>;
type UIElement = InputElementResponse<string, any, any> | {
    _type: "display";
} | IteratorElementResponse<string, any, any>;
type UIElements = UIElement[];
interface UIElementBase {
    _type: string;
}
/**
 * Type for the input element; name, data type, return data type
 * InputElementResponse<"ui.input.text", string>
 * InputElementResponse<"ui.input.file", Partial<FileDBRecord>, File>
 */
interface InputElementResponse<N extends string, V, RV = V> extends UIElementBase {
    _type: "input";
    name: N;
    valueType: V;
    /**
     * The type of the value returned from the step (page). Rich field types will operate on a json serialisable object
     * but will return a complex type to be used in subsequent steps
     */
    returnType: RV;
}
interface DisplayElementResponse<K extends string = never> extends UIElementBase {
    _type: "display";
    /** Phantom: the `key` given to the element, so visibility rules can target it. */
    key: K;
}
interface IteratorElementResponse<N extends string, E extends UIElements, D = ExtractFormData<E>[]> extends UIElementBase {
    _type: "iterator";
    name: N;
    contentData: D;
}
interface BaseInputConfig<T, O extends boolean = boolean> {
    label?: string;
    defaultValue?: T;
    helpText?: string;
    optional?: O;
    disabled?: boolean;
    validate?: ValidateFn<T>;
    onLeave?: CallbackFn<T, T>;
}
type ValidateFn<T> = (data: T, action?: string) => Promise<boolean | string> | boolean | string;
type CallbackFn<InputT, OutputT> = (data: InputT) => Promise<OutputT> | OutputT;
interface BaseUiInputResponse<K, TData> {
    __type: K;
    name: string;
    label: string;
    defaultValue?: TData;
    optional: boolean;
    disabled: boolean;
    helpText?: string;
    validationError?: string;
    /** CEL expression over the scope's inputs; the element is shown while it holds. */
    visible?: VisibilityExpression;
}
interface BaseUiMinimalInputResponse<K> {
    __type: K;
    name: string;
    validationError?: string;
    visible?: VisibilityExpression;
}
interface BaseUiDisplayResponse<K> {
    __type: K;
    visible?: VisibilityExpression;
}
type UIApiResponses = {
    display: {
        divider: UiElementDividerApiResponse;
        markdown: UiElementMarkdownApiResponse;
        header: UiElementHeaderApiResponse;
        banner: UiElementBannerApiResponse;
        image: UiElementImageApiResponse;
        code: UiElementCodeApiResponse;
        grid: UiElementGridApiResponse;
        list: UiElementListApiResponse;
        table: UiElementTableApiResponse;
        keyValue: UiElementKeyValueApiResponse;
        file: UiElementFileApiResponse;
        summary: UiElementSummaryApiResponse;
        timeline: UiElementTimelineApiResponse;
    };
    input: {
        text: UiElementInputTextApiResponse;
        number: UiElementInputNumberApiResponse;
        boolean: UiElementInputBooleanApiResponse;
        dataGrid: UiElementInputDataGridApiResponse;
        datePicker: UiElementInputDatePickerApiResponse;
        scan: UiElementInputScanApiResponse;
        file: UiElementInputFileApiResponse;
        imageCapture: UiElementInputImageCaptureApiResponse;
        signature: UiElementInputSignatureApiResponse;
    };
    select: {
        one: UiElementSelectOneApiResponse;
        table: UiElementSelectTableApiResponse;
    };
    iterator: UiElementIteratorApiResponse;
    interactive: {
        print: UiElementPrintApiResponse;
        pickList: UiElementPickListApiResponse;
    };
};
type UiElementApiResponse = UiElementDividerApiResponse | UiElementMarkdownApiResponse | UiElementHeaderApiResponse | UiElementBannerApiResponse | UiElementImageApiResponse | UiElementCodeApiResponse | UiElementGridApiResponse | UiElementListApiResponse | UiElementTableApiResponse | UiElementKeyValueApiResponse | UiElementFileApiResponse | UiElementSummaryApiResponse | UiElementTimelineApiResponse | UiElementInputTextApiResponse | UiElementInputNumberApiResponse | UiElementInputBooleanApiResponse | UiElementInputDataGridApiResponse | UiElementInputScanApiResponse | UiElementInputDatePickerApiResponse | UiElementInputFileApiResponse | UiElementInputImageCaptureApiResponse | UiElementInputSignatureApiResponse | UiElementSelectOneApiResponse | UiElementSelectTableApiResponse | UiElementIteratorApiResponse | UiElementPrintApiResponse | UiElementPickListApiResponse;
type UiElementApiResponses = UiElementApiResponse[];

declare class NonRetriableError extends Error {
    constructor(message?: string);
}

/**
 * How a client should present the current/total counter alongside the
 * progress bar: the raw count ("50 of 100"), a derived percentage ("50%"),
 * or no label at all (bar only). Absent means the client picks its default.
 */
type ProgressCounterMode = "count" | "percent" | "none";
/**
 * Snapshot of a step's progress as stored on keel.flow_step.progress and
 * returned by the flows API. The key set is closed so the Console always knows
 * how to render it; user-defined values live under `data`.
 */
type StepProgress = {
    /** Human-readable description of what the step is doing right now. */
    message?: string;
    /** How many units of work have completed. */
    current?: number;
    /** Total units of work, if known. Percent is derived client-side. */
    total?: number;
    /** What current/total count, e.g. "rows", "files", "bytes". */
    unit?: string;
    /** How the counter should be displayed. */
    counter?: ProgressCounterMode;
    /** Bounded, append-only activity feed (newest last). */
    logs?: string[];
    /** Escape hatch for arbitrary user-defined progress data. */
    data?: Record<string, unknown>;
    /** ISO timestamp of the last accepted update. Stamped by the runtime, not user code. */
    updatedAt: string;
};
/** The fields user code may set directly; the rest of StepProgress is runtime-managed. */
type ProgressPatch = {
    message?: string;
    current?: number;
    total?: number;
    unit?: string;
    counter?: ProgressCounterMode;
    data?: Record<string, unknown>;
};
/** The progress API exposed to step functions via their args. */
type ProgressHandle = {
    /** Merge the given fields into the step's progress snapshot. */
    set(patch: ProgressPatch): void;
    /** Increase `current` by n (default 1). */
    increment(n?: number): void;
    /** Append a line to the step's activity log. The log is bounded; oldest entries are dropped first. */
    log(message: string): void;
};

/** A JSON-serializable file attached to a user message. `data` is base64 so
 * requests remain library-neutral and can be recorded by scripted engines. */
interface AgentFile {
    data: string;
    mediaType: string;
    filename: string;
}
/** A JSON-serializable message in an agent conversation. Library-neutral —
 * engine adapters map this to their provider's shape. */
type AgentMessage$1 = {
    role: "user";
    content: string;
    files?: AgentFile[];
} | {
    role: "assistant";
    content: string;
    toolCalls?: ToolCallRequest[];
} | {
    role: "tool";
    toolCallId: string;
    toolName: string;
    result: string;
};
interface ToolCallRequest {
    id: string;
    name: string;
    arguments: Record<string, unknown>;
}
/** A tool as presented to the model. `parameters` is a JSON Schema object. */
interface ToolSpec {
    name: string;
    description: string;
    parameters: Record<string, unknown>;
}
interface TurnRequest$1 {
    model: string;
    system?: string;
    messages: AgentMessage$1[];
    tools?: ToolSpec[];
    /** Force the model to call a specific tool (used for structured output). */
    toolChoice?: "auto" | {
        name: string;
    };
    /** The flow step this call belongs to (e.g. "classify" or
     * "OrderTriage#1/turn-2/llm"). Attribution metadata only — engines that
     * talk to the platform AI proxy forward it as the x-keel-flow-step header;
     * other engines ignore it. */
    stepName?: string;
}
interface TurnUsage {
    inputTokens: number;
    outputTokens: number;
}
interface TurnResult$1 {
    /** Empty string when the model only returned tool calls. */
    text: string;
    toolCalls: ToolCallRequest[];
    usage: TurnUsage;
    stopReason: "end_turn" | "tool_calls";
}
/** The turn primitive: ONE model call, no looping, no tool execution.
 * The flows replay engine owns the loop; adapters must never auto-execute tools. */
interface TurnEngine$1 {
    turn(req: TurnRequest$1): Promise<TurnResult$1>;
}
type ScriptEntry$2 = TurnResult$1 | ((req: TurnRequest$1) => TurnResult$1);
/** Deterministic fake engine for tests. Returns scripted results in order. */
declare class ScriptedEngine$1 implements TurnEngine$1 {
    private readonly script;
    private _requests;
    private index;
    constructor(script: ScriptEntry$2[]);
    get requests(): readonly TurnRequest$1[];
    turn(req: TurnRequest$1): Promise<TurnResult$1>;
}
/** Helpers for building scripted turns concisely in tests. */
declare const scriptedTurn$1: {
    text(text: string): TurnResult$1;
    /** Auto-generated ids increment per process — pass an explicit `id` when asserting on ids in tests. */
    toolCall(name: string, args: Record<string, unknown>, id?: string): TurnResult$1;
};

/** A JSON-serializable value: the state being decided about, or a question's
 * instructions and criteria. */
type DecideValue = string | number | boolean | null | DecideValue[] | {
    [key: string]: DecideValue;
};
/** A yes/no question. The answer is the probability that it is true. */
interface BooleanQuestion {
    type: "boolean";
    instructions: DecideValue;
    /** Optional descriptions of what counts as true and false. */
    criteria?: {
        true?: DecideValue;
        false?: DecideValue;
    };
}
/** Pick one option. `criteria` maps each option to its description (or null). */
interface ChoiceQuestion<K extends string = string> {
    type: "choice";
    instructions: DecideValue;
    criteria: Record<K, DecideValue>;
}
/** Rate on an ordered rubric, lowest first. The answer's `score` is a
 * zero-based index and may fall between levels. */
interface ScoreQuestion {
    type: "score";
    instructions: DecideValue;
    criteria: readonly [DecideValue, DecideValue, ...DecideValue[]];
}
type DecideQuestion = BooleanQuestion | ChoiceQuestion | ScoreQuestion;
interface BooleanAnswer {
    type: "boolean";
    /** P(true), from 0 to 1. */
    probability: number;
}
interface ChoiceAnswer<K extends string = string> {
    type: "choice";
    choice: K;
    /** How concentrated the distribution is. Absent when the backing model
     * does not report one (e.g. an LLM rather than a decision model). */
    confidence?: number;
    probabilities?: Record<K, number>;
}
interface ScoreAnswer {
    type: "score";
    score: number;
    confidence?: number;
    /** Keyed by zero-based level index. */
    probabilities?: Record<string, number>;
}
type DecideAnswer = BooleanAnswer | ChoiceAnswer | ScoreAnswer;
/** The answer type for a question, keeping choice keys as a literal union. */
type AnswerFor<Q extends DecideQuestion> = Q extends {
    type: "choice";
    criteria: infer C;
} ? ChoiceAnswer<keyof C & string> : Q extends {
    type: "score";
} ? ScoreAnswer : BooleanAnswer;
interface DecideRequest {
    /** Provider-prefixed model, e.g. "typesafe/jev". */
    model: string;
    state: DecideValue;
    questions: Record<string, DecideQuestion>;
    /** The flow step this call belongs to. Attribution metadata only, as on
     * TurnRequest. */
    stepName?: string;
}
interface DecideResult {
    answers: Record<string, DecideAnswer>;
    /** The model that answered. */
    model: string;
    usage: {
        inputTokens: number;
        outputTokens: number;
    };
}
/** One decision-model call. Library-neutral, so the backing model (Jev, Clef,
 * an OpenAI decision model, an LLM) can change without touching the step. */
interface DecisionEngine {
    decide(req: DecideRequest): Promise<DecideResult>;
}
type ScriptEntry$1 = DecideResult | Record<string, DecideAnswer> | ((req: DecideRequest) => DecideResult);
/** Deterministic fake decision engine for tests. Returns scripted results in
 * order; an entry may be a full DecideResult or just its answers. */
declare class ScriptedDecisionEngine implements DecisionEngine {
    private readonly script;
    private _requests;
    private index;
    constructor(script: ScriptEntry$1[]);
    get requests(): readonly DecideRequest[];
    decide(req: DecideRequest): Promise<DecideResult>;
}

interface FieldBase {
    /** What the field should contain, in plain language. */
    instructions?: string;
    /** Probability of "not in the input" above which the value is null
     * (default 0.5). Raise it to get more guesses, lower it to get more nulls. */
    nullThreshold?: number;
}
/** A span of the input text. */
interface TextField extends FieldBase {
    type: "text";
}
interface NumberField extends FieldBase {
    type: "number";
    integer?: boolean;
    /** 0 to 6. */
    decimals?: number;
    /** Unit label, e.g. "USD" or "kg". */
    unit?: string;
}
/** An ISO date (`YYYY-MM-DD`), time or datetime. */
interface DateField extends FieldBase {
    type: "date" | "time" | "datetime";
}
/** A length of time as a number of `unit`s. */
interface DurationField extends FieldBase {
    type: "duration";
    unit?: "seconds" | "minutes" | "hours" | "days" | "weeks" | "months" | "years";
    integer?: boolean;
    decimals?: number;
}
/** Every matching item, in input order. */
interface ListField extends FieldBase {
    type: "list";
    items: "text" | "number" | "date";
    decimals?: number;
}
/** A value the input implies but may not state, as a distribution between
 * `min` and `max`. Numbers, or ISO dates for a date estimate. */
interface EstimateField extends FieldBase {
    type: "estimate";
    min: number | string;
    max: number | string;
    /** Grid size: a number (days for a date estimate), or "month" / "year". */
    step?: number | "month" | "year";
    scale?: "linear" | "log";
}
type ExtractField = TextField | NumberField | DateField | DurationField | ListField | EstimateField;
interface ScalarAnswerBase<T> {
    /** The answer, or null when the input does not determine it. */
    value: T | null;
    /** The best guess even when `value` is null. */
    guess?: T | null;
    /** Probability that the input does not contain the value, 0 to 1. */
    pNull?: number;
    /** Confidence in `value`, 0 to 1. */
    confidence?: number;
}
interface TextAnswer extends ScalarAnswerBase<string> {
    type: "text";
    /** [start, end) character offsets into `state`. Only present when `state`
     * was a string. */
    span?: [number, number];
}
interface NumberAnswer extends ScalarAnswerBase<number> {
    type: "number";
}
interface DateAnswer<T extends DateField["type"] = DateField["type"]> extends ScalarAnswerBase<string> {
    type: T;
}
interface DurationAnswer extends ScalarAnswerBase<number> {
    type: "duration";
}
interface ListAnswer<T = string | number> {
    type: "list";
    value: T[];
    /** One [start, end) offset pair per item. Only present when `state` was a
     * string. */
    spans?: [number, number][];
    confidence?: number;
}
interface EstimateAnswer<T = number | string> {
    type: "estimate";
    /** Point estimate. */
    value: T | null;
    mean?: T;
    median?: T;
    /** p10..p90 is the 80% interval. */
    p10?: T;
    p90?: T;
    /** Probability that the true value is below `min` / above `max`. */
    pBelow?: number;
    pAbove?: number;
}
type ExtractAnswer = TextAnswer | NumberAnswer | DateAnswer | DurationAnswer | ListAnswer | EstimateAnswer;
/** The answer type for a field: list items and date estimates come back as
 * strings, everything numeric as numbers. */
type ExtractAnswerFor<F extends ExtractField> = F extends TextField ? TextAnswer : F extends NumberField ? NumberAnswer : F extends DateField ? DateAnswer<F["type"]> : F extends DurationField ? DurationAnswer : F extends ListField ? ListAnswer<F["items"] extends "number" ? number : string> : F extends EstimateField ? EstimateAnswer<F["min"] extends string ? string : number> : never;
/** An image to read alongside the state: PNG, JPEG or WebP. */
interface ExtractImage {
    contentType: string;
    base64: string;
}
interface ExtractRequest {
    /** Provider-prefixed model, e.g. "cloudflare/clairic". */
    model: string;
    /** Text to read from. JSON state is serialised before it is sent. */
    state: string;
    fields: Record<string, ExtractField>;
    images?: ExtractImage[];
    /** ISO date that anchors dates written without a year. */
    referenceDate?: string;
    /** The flow step this call belongs to. Attribution metadata only. */
    stepName?: string;
}
interface ExtractResult {
    answers: Record<string, ExtractAnswer>;
    /** True when the input was too long and was cut before it was read. */
    truncated: boolean;
    model: string;
    usage: {
        inputTokens: number;
        outputTokens: number;
    };
}
/** One extraction-model call. Library-neutral, so the backing model can
 * change without touching the step. */
interface ExtractionEngine {
    extract(req: ExtractRequest): Promise<ExtractResult>;
}
type ScriptEntry = ExtractResult | Record<string, ExtractAnswer> | ((req: ExtractRequest) => ExtractResult);
/** Deterministic fake extraction engine for tests. Returns scripted results
 * in order; an entry may be a full ExtractResult or just its answers. */
declare class ScriptedExtractionEngine implements ExtractionEngine {
    private readonly script;
    private _requests;
    private index;
    constructor(script: ScriptEntry[]);
    get requests(): readonly ExtractRequest[];
    extract(req: ExtractRequest): Promise<ExtractResult>;
}
/** The state an extract step reads from: text, or any JSON value. */
type ExtractState = DecideValue;

declare const enum STEP_STATUS {
    NEW = "NEW",
    RUNNING = "RUNNING",
    PENDING = "PENDING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED"
}
declare const enum STEP_TYPE {
    FUNCTION = "FUNCTION",
    UI = "UI",
    DELAY = "DELAY",
    COMPLETE = "COMPLETE",
    FLOW = "FLOW"
}
/** A function used to calculate the delay between attempting a retry. The returned value is the number of ms of delay. */
type RetryPolicyFn = (retry: number) => number;
/**
 * Returns a linear backoff retry delay.
 * @param intervalS duration in seconds before the first retry. The second retry will double it, the third triple it and so on.
 */
declare const RetryBackoffLinear: (intervalS: number) => RetryPolicyFn;
/**
 * Retuns a constant retry delay.
 * @param intervalS duration in seconds between retries.
 */
declare const RetryConstant: (intervalS: number) => RetryPolicyFn;
/**
 * Returns an exponential backoff retry delay.
 * @param intervalS the base duration in seconds.
 */
declare const RetryBackoffExponential: (intervalS: number) => RetryPolicyFn;
type FlowDefinition<I, R> = {
    name: string;
    config: FlowConfig;
    fn: (ctx: any, inputs: I) => R;
};
type FlowRunOptions<C extends FlowConfig, I> = ([I] extends [never] ? {
    inputs?: never;
} : {
    inputs: I;
}) & {
    /** Step name; defaults to flow.name. Required when calling the same flow more than once (e.g. in a loop). */
    name?: string;
    stage?: ExtractStageKeys<C>;
    /** Number of times to retry creating the child run after it fails. Defaults to 0. */
    retries?: number;
};
type FlowHandoffOptions<I> = [I] extends [never] ? {
    inputs?: never;
} : {
    inputs: I;
};
type ContinueOptions = {
    after?: Date;
};
type FlowResult<R> = R extends {
    __type: "ui.complete";
    data?: infer D;
} ? D : R;
interface FlowContext<C extends FlowConfig, E, S, Id, I, H extends NullableHardware, T = AnyToolInputs> {
    step: Step<C>;
    ui: UI<C, H>;
    complete: Complete<C, I, T>;
    env: E;
    now(): Date;
    secrets: S;
    identity: Id;
    trace: TraceAPI;
    module(name: string): {
        secret(key: string): string;
        server: {
            do(request: {
                method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
                path: string;
                query?: Record<string, string | string[]>;
                headers?: Record<string, string>;
                body?: unknown;
            }): Promise<{
                status: number;
                headers: Record<string, string[]>;
                body: unknown;
            }>;
        };
    };
    flows: {
        run<I2, R>(flow: FlowDefinition<I2, R>, opts: FlowRunOptions<C, I2>): Promise<FlowResult<Awaited<R>>>;
        handoff<I2, R>(flow: FlowDefinition<I2, R>, opts: FlowHandoffOptions<I2>): Promise<never>;
    };
    continue: [I] extends [never] ? (inputs?: never, opts?: ContinueOptions) => Promise<never> : (inputs: I, opts?: ContinueOptions) => Promise<never>;
}
type NullableHardware = Hardware | undefined;
type Hardware = {
    printers: Printer[];
};
interface Printer {
    name: string;
}
type JsonValue$1<T> = T extends string | number | boolean | null ? T : T extends (...args: any[]) => any ? never : T extends (infer E)[] ? JsonValue$1<E>[] : T extends object ? keyof T extends never ? never : {
    [K in keyof T]: JsonValue$1<T[K]>;
} : never;
type Serializable<T> = string | number | boolean | null | void | {
    [K in keyof T]: JsonValue$1<T[K]>;
};
type StepReturn<R> = [R] extends [JsonValue$1<R> | void] ? R : JsonValue$1<R>;
type StepOptions<C extends FlowConfig> = {
    stage?: ExtractStageKeys<C>;
    /** Number of times to retry the step after it fails. Defaults to 4. */
    retries?: number;
    /** Function to calculate the delay before retrying this step. By default steps will be retried immediately. */
    retryPolicy?: RetryPolicyFn;
    /** Maximum time in milliseconds to wait for the step to complete. Defaults to 60000 (1 minute). */
    timeout?: number;
    /** A function to call if the step fails after it exhausts all retries. */
    onFailure?: () => Promise<void> | void;
    /** Message shown as the step's progress while it runs. Sugar for an initial `progress.set({ message })`. */
    loadingMessage?: string;
};
type Step<C extends FlowConfig> = {
    <R extends Serializable<R>>(
    /** The unique name of this step. */
    name: string, 
    /** Configuration options for the step. */
    options: StepOptions<C>, 
    /** The step function to execute. */
    fn: StepFunction<C, StepReturn<R>>): Promise<R>;
    <R extends Serializable<R>>(
    /** The unique name of this step. */
    name: string, 
    /** The step function to execute. */
    fn: StepFunction<C, StepReturn<R>>): Promise<R>;
};
type StepArgs<C extends FlowConfig> = {
    attempt: number;
    stepOptions: StepOptions<C>;
    /** Report what the step is doing while it runs. Updates are throttled, written to the run's state, and surfaced by the flows API. */
    progress: ProgressHandle;
};
type StepFunction<C extends FlowConfig, R> = (args: StepArgs<C>) => Promise<R>;
interface FlowConfig {
    /** The stages to organise the steps in the flow. */
    stages?: StageConfig[];
    /**
     * The internal title of the flow as shown to authenticated Console users.
     *
     * For public/shareable flow links, set `externalAccess.title` when the
     * externally visible title should differ from this internal title.
     */
    title?: string;
    /**
     * The internal description of the flow as shown to authenticated Console users.
     *
     * For public/shareable flow links, set `externalAccess.description` when the
     * externally visible description should differ from this internal description.
     */
    description?: string;
    /**
     * Content and presentation options for public/shareable flow links.
     *
     * These values are used before an external visitor starts the flow. If
     * `title` or `description` are set here, they replace the top-level internal
     * `title` or `description` in external metadata responses so internal copy is
     * not exposed to public/shared users.
     */
    externalAccess?: FlowExternalAccessConfig;
}
interface FlowExternalAccessConfig {
    /**
     * The title shown to public/shareable link visitors before the flow starts.
     *
     * When set, this is returned as `config.title` in external metadata responses
     * instead of the top-level internal `title`.
     */
    title?: string;
    /**
     * The description shown to public/shareable link visitors before the flow starts.
     *
     * When set, this is returned as `config.description` in external metadata
     * responses instead of the top-level internal `description`.
     */
    description?: string;
    /**
     * Additional introduction content shown on the external start screen before
     * the visitor starts the flow.
     */
    introduction?: string;
    /**
     * Whether the external flow should show company branding when branding is
     * available and configured in the project settings.
     *
     * Defaults to `true`.
     *
     * @default true
     */
    branded?: boolean;
}
interface FlowConfigAPI {
    stages?: StageConfigObject[];
    title: string;
    description?: string;
    externalAccess?: FlowExternalAccessConfig;
}
type FlowFunction<C extends FlowConfig, E, S, Id, I = undefined, H extends NullableHardware = undefined> = (ctx: FlowContext<C, E, S, Id, I, H>, inputs: I) => Promise<CompleteOptions<C, I> | any | void>;
type TaskFlowFunction<C extends FlowConfig, E, S, Id, T, H extends NullableHardware = undefined> = (ctx: FlowContext<C, E, S, Id, T, H>, task: T) => Promise<CompleteOptions<C, T> | any | void>;
type ExtractStageKeys<T extends FlowConfig> = T extends {
    stages: infer S;
} ? S extends ReadonlyArray<infer U> ? U extends string ? U : U extends {
    key: infer K extends string;
} ? K : never : never : never;
type StageConfigObject = {
    /** The unique key of the stage. */
    key: string;
    /** The name of the stage as shown in the Console. */
    name: string;
    /** The description of the stage as shown in the Console. */
    description?: string;
    /** Whether the stage is initially hidden in the Console. */
    initiallyHidden?: boolean;
    /** For a stage spliced in from a composed child flow, the namespaced key of the parent flow's stage it nests under. Absent on top-level stages. */
    parentKey?: string;
};
type StageConfig = string | StageConfigObject;
declare function insertNewStep(db: Kysely<any>, runId: string, name: string, stage: string | undefined): Promise<void>;
type ChildRunOpts = {
    inputs: unknown;
    stage?: string;
    expectedFailures: number;
};
declare function createChildRun(db: Kysely<any>, runId: string, stepName: string, childFlowName: string, opts: ChildRunOpts): Promise<void>;
declare function createFlowContext<C extends FlowConfig, E, S, Id, I, H extends NullableHardware>(runId: string, data: any, action: string | null, callback: string | null, element: string | null, expectedStepId: string | null, spanId: string, ctx: {
    env: E;
    now: () => Date;
    secrets: S;
    identity: Id;
    trace: TraceAPI;
    engine?: TurnEngine$1;
    decisionEngine?: DecisionEngine;
    extractionEngine?: ExtractionEngine;
    /** Platform AI gateway (the flows AI proxy) config, delivered via the
     * invoke meta when the environment has one configured. Used by
     * resolveEngine as the fallback when no customer API key is set. */
    aiGateway?: {
        baseUrl: string;
    };
    /** Name of the flow being invoked (the JSON-RPC method). Forwarded to the
     * platform AI proxy as the x-keel-flow-name attribution header on the
     * gateway path. */
    flowName?: string;
    module: FlowContext<C, E, S, Id, I, H>["module"];
}): FlowContext<C, E, S, Id, I, H>;
declare function runWithStatementTimeout<T>(db: Kysely<any>, timeoutMs: number, fn: () => Promise<T>): Promise<T>;

/**
 * What syncUpsert accepts as a model: a generated `models.<name>` API (anything with a typed
 * `create`). The API's create-values type becomes the type of `values`, so a projector gets the
 * same checking as `models.<name>.create`. The table metadata the statement needs lives on the
 * runtime ModelAPI instance behind that type and is read at run time.
 */
type SyncUpsertModel<V = Record<string, unknown>, R = unknown> = {
    create(values: V): Promise<R>;
};
/**
 * Insert a model row keyed by an external identifier, or update the existing row with the same
 * key, in a single `INSERT ... ON CONFLICT DO UPDATE` statement.
 *
 * This is the write primitive for sync projectors. The hand-rolled `findOne` + `create` /
 * `update` pair is not atomic: two writers racing on the same vendor record (a webhook and a
 * sync page, or two sync ticks) both miss on the read and one of them fails on the unique
 * constraint. A single upsert statement lets Postgres arbitrate, so it is safe to call
 * concurrently and safe to replay.
 *
 * `conflictField` must be declared `@unique` in the schema; that is what gives the table the
 * unique constraint the statement targets. Values go through the same pipeline as
 * `models.<name>.create`, so rich Keel types and belongs-to references (`{ id }`) work the same
 * way. Nested has-many creates are not supported because they cannot be expressed as one
 * statement.
 *
 * The write runs on `useDatabase()`, so inside a transaction it lands in that transaction. The
 * `id`, `created_at` and `updated_at` columns are never overwritten on conflict; `updated_at` is
 * bumped by the table's trigger when the row content changes.
 *
 * File fields get the same cleanup as `models.<name>.update`: when the upsert replaces or clears
 * a stored file on an existing row, the previous storage object is deleted once the surrounding
 * transaction commits. Knowing which keys were replaced takes a read of the row before the
 * statement, so a write that touches a File field runs in a transaction (joining the caller's
 * when there is one) and serialises with other writers on the same key through a
 * transaction-scoped advisory lock. Concurrent writers therefore see each other's files and no
 * key is deleted while a row still points at it.
 *
 * @example
 * await syncUpsert(models.stripeCustomer, "customerId", {
 *   customerId: customer.id,
 *   email: customer.email,
 * });
 */
declare function syncUpsert<V extends Record<string, any>, R = V>(model: SyncUpsertModel<V, R>, conflictField: Extract<keyof V, string>, values: V): Promise<R>;

type RecordState = "pending" | "applied" | "failed" | "skipped";
type RecordSource = "sync" | "reconcile" | "webhook";
type IngestItem = {
    externalId: string;
    payload: unknown;
    sourceUpdatedMs?: number | null;
};
type SyncRecordRow = {
    integrationName: string;
    connectionId: string;
    entity: string;
    scope: string;
    externalId: string;
    payload: unknown;
    payloadShed: boolean;
    payloadHash: string;
    sourceUpdatedMs: number | null;
    seq: number;
    revision: number;
    state: RecordState;
    attempts: number;
    lastError: string | null;
    appliedAt: Date | null;
    deletedAt: Date | null;
    firstSeenAt: Date;
    lastSeenAt: Date;
    lastSeenReconcileId: string | null;
    source: RecordSource;
    runId: string | null;
};

/**
 * A module as seen through its generated `_module.gen.ts` (`import * as acme from "../_module.gen"`):
 * `name` is the integration name and `syncEntities` the manifest's declared sync entities. Passing
 * the module instead of a bare name narrows the `entity` argument to those declared names.
 */
type SyncModuleRef = {
    readonly name: string;
    readonly syncEntities?: ReadonlyArray<{
        readonly name: string;
    }>;
};
type SyncEntityOf<M> = M extends {
    syncEntities: ReadonlyArray<{
        name: infer N extends string;
    }>;
} ? N : string;
type SyncRecordOptions = {
    scope?: string;
    connectionId?: string;
};
/**
 * One row of the record store as `syncRecord` returns it. Field names match the records
 * endpoint of the integrations API, so the two views of a record agree.
 *
 * `payload` is the vendor object exactly as it was last ingested. It is `null` in two cases the
 * `payloadShed` flag tells apart: the vendor served null (`payloadShed: false`), or retention
 * (`KEEL_SYNC_PAYLOAD_RETENTION_DAYS`) shed it (`payloadShed: true`). A shed row keeps its
 * `payloadHash`, so an identical re-fetch is still a no-op and the payload only returns once the
 * vendor record changes or is re-ingested with `syncIngest`.
 */
type SyncRecord = Omit<SyncRecordRow, "lastSeenReconcileId">;
type SyncIngestOptions = SyncRecordOptions & {
    source?: RecordSource;
    state?: "pending" | "applied";
    runId?: string | null;
};
type SyncIngestResult = {
    changed: boolean;
    state: RecordState;
    seq: number;
    revision: number;
};
/**
 * Read one record from the sync record store: the last payload the engine (or `syncIngest`)
 * stored for a vendor id, with its state and bookkeeping. Returns null when the entity has never
 * seen that id.
 *
 * Reads on `useDatabase()`, so it works inside flows, functions, subscribers and routes, and sees
 * the caller's own uncommitted writes when called inside a transaction.
 *
 * `integration` is the integration name, or the module's generated `_module.gen.ts` namespace
 * import, which narrows `entity` to the manifest's declared sync entities.
 *
 * @example
 * import * as xero from "../_module.gen";
 * const rec = await syncRecord(xero, "invoices", invoiceId);
 * if (rec && !rec.payloadShed) {
 *   const lineItems = (rec.payload as XeroInvoice).LineItems;
 * }
 */
declare function syncRecord<M extends SyncModuleRef>(module: M, entity: SyncEntityOf<M>, externalId: string, opts?: SyncRecordOptions): Promise<SyncRecord | null>;
declare function syncRecord(integration: string, entity: string, externalId: string, opts?: SyncRecordOptions): Promise<SyncRecord | null>;
/**
 * Write a vendor record the caller fetched itself — a webhook processor, an operator flow — into
 * the sync record store, keyed exactly as the walk keys it (the module's `key(item)` value as
 * `externalId`). The store's change guard applies: an identical payload only stamps
 * `last_seen_at`, and a payload older (by `sourceUpdatedMs`) than the stored one is dropped, so
 * a late webhook never overwrites a newer version and the next incremental walk that re-fetches
 * the same record sees a no-op.
 *
 * With the default `state: "pending"` the next tick's apply phase projects the row through the
 * entity's `upsert`, and until then it shows in the entity's `pendingCount`. A handler that
 * projects inline (with `syncUpsert`) passes `state: "applied"`: the row is marked applied when
 * this ingest changed it, or when it was pending for exactly this payload (the probe-then-project
 * pattern below). A row that holds a newer version, or that an operator skipped, is left alone, so
 * a stale or repeated delivery never un-does anything.
 *
 * Recommended shape for a webhook processor — ask the store first, project only what is news:
 *
 * @example
 * const item = { externalId: invoice.InvoiceID, payload: invoice, sourceUpdatedMs: Date.parse(invoice.UpdatedDateUTC) };
 * const probe = await syncIngest(xero, "invoices", item);
 * if (probe.changed) {
 *   await syncUpsert(models.xeroInvoice, "invoiceId", project(invoice));
 *   await syncIngest(xero, "invoices", item, { state: "applied" });
 * }
 */
declare function syncIngest<M extends SyncModuleRef>(module: M, entity: SyncEntityOf<M>, item: IngestItem, opts?: SyncIngestOptions): Promise<SyncIngestResult>;
declare function syncIngest(integration: string, entity: string, item: IngestItem, opts?: SyncIngestOptions): Promise<SyncIngestResult>;

type SyncStrategy = "cursor" | "page" | "sinceId" | "updatedSortStop" | "pageJump" | "dateWindow";
type IntegrationServer = {
    do(request: {
        method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
        path: string;
        query?: Record<string, string | string[]>;
        headers?: Record<string, string>;
        body?: unknown;
    }): Promise<{
        status: number;
        headers: Record<string, string[]>;
        body: unknown;
    }>;
};
type ListArgs = {
    scope: string;
    pageSize: number;
    mode?: "incremental" | "reconcile";
    server: IntegrationServer;
    position?: string | number | null;
    page?: number;
    watermark?: string | number | null;
    overlap?: number;
    window?: {
        from: string | null;
    };
};
type SyncPage<W> = {
    items: W[];
    nextPosition?: string | number | null;
    hasMore?: boolean;
};
type ReconcileArgs = {
    scope: string;
    pageSize: number;
    server: IntegrationServer;
    position?: string | number | null;
};
type ReconcilePage = {
    deletedKeys: string[];
    nextPosition?: string | number | null;
    hasMore?: boolean;
};
type SyncDefinition<W> = {
    list: (args: ListArgs) => Promise<SyncPage<W>>;
    key: (item: W) => string;
    upsert: (item: W) => Promise<unknown>;
    remove?: (key: string, last: W | null) => Promise<unknown>;
    reconcile?: (args: ReconcileArgs) => Promise<ReconcilePage>;
    getUpdatedAt?: (item: W) => Date | string | number | null | undefined;
    getId?: (item: W) => string | number;
    scopes?: () => Promise<string[]>;
    pageSize?: number;
    overlapMs?: number;
    overlapCount?: number;
};
declare function defineSync<W>(definition: SyncDefinition<W>): SyncDefinition<W>;
type SyncEntityDeclaration = {
    readonly name: string;
    readonly cadence: string;
    readonly strategy: string;
};
type TickInputs = {
    work?: WorkItem[];
    force?: boolean;
    entities?: string[];
    reconcile?: boolean;
};
type WorkItem = {
    entity: string;
    scope: string;
    strategy: SyncStrategy;
    maxRows: number | null;
    mode?: "incremental" | "reconcile";
    phase?: "ingest" | "apply";
};
type SyncEngineHooks = {
    beforeCursorWrite?: (info: {
        entity: string;
        scope: string;
        page: number;
    }) => Promise<void> | void;
    beforeMarkApplied?: (info: {
        entity: string;
        scope: string;
        externalId: string;
    }) => Promise<void> | void;
};
type SyncEngineInternals = {
    hooks?: SyncEngineHooks;
};
type RateLimitConfig = {
    remainingHeader: string;
    reserve: number;
    window: "daily" | "hourly" | "minute";
};
type SyncEngineOptions = SyncEngineInternals & {
    rateLimit?: RateLimitConfig;
};
declare function runSync(integrationName: string, entities: ReadonlyArray<SyncEntityDeclaration>, syncs: Record<string, SyncDefinition<any>>, options?: SyncEngineOptions): (ctx: any, inputs: TickInputs | undefined) => Promise<any>;
declare function parseCadenceMs(cadence: string | null | undefined): number;

type GenerateOptions<R> = {
    /** Provider-prefixed model, e.g. "anthropic/claude-sonnet-4-6". */
    model: string;
    prompt: string;
    /** Optional system instructions. */
    system?: string;
    /** Keel files to include with the prompt. Stored File values and InlineFile values are supported. */
    files?: readonly InlineFile[];
    /** Standard Schema for the typed result. Omit for plain text. */
    result?: StandardSchemaV1<unknown, R>;
    /** Max wall-clock ms for the step (default 300000). */
    timeout?: number;
};
/**
 * Run one typed LLM call as a single checkpointed flow step. No tools, no loop:
 * it's an ordinary step, so the result is cached on replay and retried on
 * transient failure. Pass a `result` schema for structured output (validated
 * with a bounded repair loop) or omit it to get the model's plain text.
 *
 * Takes the flow `ctx` explicitly so it can be called as a free function:
 *
 *   const triage = await experimental.ai.generate(ctx, "classify", {
 *     model: "anthropic/claude-haiku-4-5",
 *     prompt: `Classify this ticket: ${body}`,
 *     files: [ticket.attachment],
 *     result: z.object({ category: z.enum(["billing", "bug", "other"]) }),
 *   });
 */
declare function generate<R>(ctx: any, name: string, options: GenerateOptions<R> & {
    result: StandardSchemaV1<unknown, R>;
}): Promise<R>;
declare function generate(ctx: any, name: string, options: GenerateOptions<never>): Promise<string>;

type DecideOptions<Q extends Record<string, DecideQuestion>> = {
    /** Provider-prefixed decision model. Default "typesafe/jev". */
    model?: string;
    /** What is being decided about: text, or any JSON value. */
    state: DecideValue;
    /** Named questions; each name becomes a key on the result. */
    questions: Q;
    /** Max wall-clock ms for the step (default 30000). */
    timeout?: number;
};
type DecideAnswers<Q extends Record<string, DecideQuestion>> = {
    [K in keyof Q]: AnswerFor<Q[K]>;
};
/**
 * Ask a decision model typed questions about some state, as a single
 * checkpointed flow step. Each answer carries probabilities instead of free
 * text, so the flow can act on the answer or fall back (for example to a human
 * task) when the model is unsure. The result is cached on replay and the call
 * is retried on transient failure, like any other step.
 *
 *   const triage = await experimental.ai.decide(ctx, "triage", {
 *     state: { subject, body },
 *     questions: {
 *       team: {
 *         type: "choice",
 *         instructions: "Which team should handle this?",
 *         criteria: { billing: "Invoices and refunds", support: "Bugs" },
 *       },
 *       urgent: { type: "boolean", instructions: "Is this urgent?" },
 *     },
 *   });
 *   triage.team.choice;        // "billing" | "support"
 *   triage.urgent.probability; // 0..1
 */
declare function decide<const Q extends Record<string, DecideQuestion>>(ctx: any, name: string, options: DecideOptions<Q>): Promise<DecideAnswers<Q>>;

type ExtractOptions<F extends Record<string, ExtractField>> = {
    /** Provider-prefixed extraction model. Default "cloudflare/clairic". */
    model?: string;
    /** What to read: text, or any JSON value (serialised before it is sent).
     * Answer spans are only returned for text state. */
    state: ExtractState;
    /** Up to four PNG, JPEG or WebP images read alongside the state: Keel files
     * or `data:` URLs. */
    images?: (InlineFile | string)[];
    /** Named fields; each name becomes a key on the result. */
    fields: F;
    /** ISO date that anchors dates written without a year, e.g. the date the
     * email was received. */
    referenceDate?: string;
    /** Max wall-clock ms for the step (default 30000). */
    timeout?: number;
};
type ExtractAnswers<F extends Record<string, ExtractField>> = {
    [K in keyof F]: ExtractAnswerFor<F[K]>;
};
/**
 * Read typed values out of unstructured text and images with an extraction
 * model, as a single checkpointed flow step. Every value comes back with a
 * confidence and is null when the input does not contain it, so the flow can
 * act on what it is sure of and send the rest to a person. The result is
 * cached on replay and the call is retried on transient failure, like any
 * other step.
 *
 *   const invoice = await experimental.ai.extract(ctx, "read invoice", {
 *     state: email.body,
 *     fields: {
 *       orderId: { type: "text", instructions: "The order number" },
 *       amount: { type: "number", decimals: 2, unit: "USD" },
 *       dueDate: { type: "date" },
 *     },
 *   });
 *   invoice.amount.value;      // number | null
 *   invoice.amount.confidence; // 0..1
 *
 * Extraction models are not reliable at multi-step arithmetic: extract the
 * parts (line items, quantities) and do the sums in code.
 */
declare function extract<const F extends Record<string, ExtractField>>(ctx: any, name: string, options: ExtractOptions<F>): Promise<ExtractAnswers<F>>;

type JsonValue = string | number | boolean | null | JsonValue[] | {
    [k: string]: JsonValue;
};
interface ToolDefinition$1<P = any> {
    /** snake_case identifier the model sees. */
    name: string;
    description: string;
    /** Extra guidance on when/how to use the tool, appended to the description. */
    usage?: string;
    /** Standard Schema (Zod v4) for the tool's arguments. */
    parameters: StandardSchemaV1<unknown, P>;
    /** true = always gate behind a UI approval step; predicate = gate when it returns true. */
    approval?: boolean | ((args: P) => boolean);
    execute: (args: P) => Promise<JsonValue | void>;
}
declare function defineTool$1<P>(config: ToolDefinition$1<P>): Readonly<ToolDefinition$1<P>>;

interface AgentConfig$1<I = any, R = any> {
    /** Unique agent name; used to namespace checkpointed steps. */
    name: string;
    model: string;
    instructions: string;
    tools?: ReadonlyArray<ToolDefinition$1>;
    /** Sealed prompt template — callers pass inputs, never a raw prompt. */
    prompt: (args: {
        inputs: I;
        context: Record<string, unknown>;
    }) => string;
    /** Result contract. Omit for free-text agents (run resolves to final assistant text). */
    result?: StandardSchemaV1<unknown, R>;
    /** Max LLM turns before the run fails. Default 10. */
    maxTurns?: number;
    /**
     * Pre-run hook; the object it returns merges into the prompt template context.
     * Like the agent body, this runs again on every orchestrator replay, so any
     * side effects must be wrapped in `ctx.step(...)` to stay idempotent (see the
     * `beforeRun` test, which loads its value through a checkpointed step).
     */
    beforeRun?: (ctx: any, args: {
        inputs: I;
    }) => Promise<Record<string, unknown> | void>;
    /**
     * Post-run hook, called with the final result once the agent completes. Like
     * `beforeRun` it runs again on every orchestrator replay, so any side effects
     * (writes, notifications) must be wrapped in `ctx.step(...)` to stay
     * idempotent — an un-checkpointed write here repeats on each replay.
     */
    afterRun?: (ctx: any, result: R | string) => Promise<void>;
}
interface Agent$1<I = any, R = any> {
    readonly name: string;
    readonly config: AgentConfig$1<I, R>;
    run(ctx: any, inputs: I): Promise<any>;
}
declare function defineAgent$1<I = any, R = any>(config: AgentConfig$1<I, R>): Agent$1<I, R>;

type ai_BooleanAnswer = BooleanAnswer;
type ai_BooleanQuestion = BooleanQuestion;
type ai_ChoiceAnswer<K extends string = string> = ChoiceAnswer<K>;
type ai_ChoiceQuestion<K extends string = string> = ChoiceQuestion<K>;
type ai_DateAnswer<T extends DateField["type"] = DateField["type"]> = DateAnswer<T>;
type ai_DateField = DateField;
type ai_DecideAnswer = DecideAnswer;
type ai_DecideAnswers<Q extends Record<string, DecideQuestion>> = DecideAnswers<Q>;
type ai_DecideOptions<Q extends Record<string, DecideQuestion>> = DecideOptions<Q>;
type ai_DecideQuestion = DecideQuestion;
type ai_DecideRequest = DecideRequest;
type ai_DecideResult = DecideResult;
type ai_DecideValue = DecideValue;
type ai_DecisionEngine = DecisionEngine;
type ai_DurationAnswer = DurationAnswer;
type ai_DurationField = DurationField;
type ai_EstimateAnswer<T = number | string> = EstimateAnswer<T>;
type ai_EstimateField = EstimateField;
type ai_ExtractAnswer = ExtractAnswer;
type ai_ExtractAnswerFor<F extends ExtractField> = ExtractAnswerFor<F>;
type ai_ExtractAnswers<F extends Record<string, ExtractField>> = ExtractAnswers<F>;
type ai_ExtractField = ExtractField;
type ai_ExtractImage = ExtractImage;
type ai_ExtractOptions<F extends Record<string, ExtractField>> = ExtractOptions<F>;
type ai_ExtractRequest = ExtractRequest;
type ai_ExtractResult = ExtractResult;
type ai_ExtractionEngine = ExtractionEngine;
type ai_GenerateOptions<R> = GenerateOptions<R>;
type ai_ListAnswer<T = string | number> = ListAnswer<T>;
type ai_ListField = ListField;
type ai_NumberAnswer = NumberAnswer;
type ai_NumberField = NumberField;
type ai_ScoreAnswer = ScoreAnswer;
type ai_ScoreQuestion = ScoreQuestion;
type ai_TextAnswer = TextAnswer;
type ai_TextField = TextField;
declare const ai_decide: typeof decide;
declare const ai_extract: typeof extract;
declare const ai_generate: typeof generate;
declare namespace ai {
  export { type Agent$1 as Agent, type AgentConfig$1 as AgentConfig, type AgentMessage$1 as AgentMessage, type ai_BooleanAnswer as BooleanAnswer, type ai_BooleanQuestion as BooleanQuestion, type ai_ChoiceAnswer as ChoiceAnswer, type ai_ChoiceQuestion as ChoiceQuestion, type ai_DateAnswer as DateAnswer, type ai_DateField as DateField, type ai_DecideAnswer as DecideAnswer, type ai_DecideAnswers as DecideAnswers, type ai_DecideOptions as DecideOptions, type ai_DecideQuestion as DecideQuestion, type ai_DecideRequest as DecideRequest, type ai_DecideResult as DecideResult, type ai_DecideValue as DecideValue, type ai_DecisionEngine as DecisionEngine, type ai_DurationAnswer as DurationAnswer, type ai_DurationField as DurationField, type ai_EstimateAnswer as EstimateAnswer, type ai_EstimateField as EstimateField, type ai_ExtractAnswer as ExtractAnswer, type ai_ExtractAnswerFor as ExtractAnswerFor, type ai_ExtractAnswers as ExtractAnswers, type ai_ExtractField as ExtractField, type ai_ExtractImage as ExtractImage, type ai_ExtractOptions as ExtractOptions, type ai_ExtractRequest as ExtractRequest, type ai_ExtractResult as ExtractResult, type ai_ExtractionEngine as ExtractionEngine, type ai_GenerateOptions as GenerateOptions, type ai_ListAnswer as ListAnswer, type ai_ListField as ListField, type ai_NumberAnswer as NumberAnswer, type ai_NumberField as NumberField, type ai_ScoreAnswer as ScoreAnswer, type ai_ScoreQuestion as ScoreQuestion, type ai_TextAnswer as TextAnswer, type ai_TextField as TextField, type ToolDefinition$1 as ToolDefinition, type TurnEngine$1 as TurnEngine, type TurnRequest$1 as TurnRequest, type TurnResult$1 as TurnResult, ai_decide as decide, defineAgent$1 as defineAgent, defineTool$1 as defineTool, ai_extract as extract, ai_generate as generate };
}

type testing_ScriptedDecisionEngine = ScriptedDecisionEngine;
declare const testing_ScriptedDecisionEngine: typeof ScriptedDecisionEngine;
type testing_ScriptedExtractionEngine = ScriptedExtractionEngine;
declare const testing_ScriptedExtractionEngine: typeof ScriptedExtractionEngine;
declare namespace testing {
  export { testing_ScriptedDecisionEngine as ScriptedDecisionEngine, ScriptedEngine$1 as ScriptedEngine, testing_ScriptedExtractionEngine as ScriptedExtractionEngine, scriptedTurn$1 as scriptedTurn };
}

interface AiSdkEngineOptions {
    /** Standard API key (sk-ant-api...), sent as x-api-key. */
    apiKey?: string;
    /** Bearer token (sk-ant-oat... OAuth tokens), sent as Authorization: Bearer
     * together with the anthropic-beta oauth header. */
    authToken?: string;
    /** Scoped bearer token minted by the Keel runtime for the platform AI proxy,
     * sent as Authorization: Bearer. Unlike authToken, NO anthropic-beta oauth
     * header is attached — the proxy fronts the standard Messages API. */
    proxyToken?: string;
    /** Override the provider base URL (e.g. the platform AI proxy). Must end in
     * /v1 — the provider appends /messages verbatim. */
    baseURL?: string;
    /** Extra headers merged into every request (e.g. x-keel-flow-run-id and
     * x-keel-flow-name for usage attribution at the platform AI proxy). Also
     * acts as the signal that per-call attribution headers (x-keel-flow-step)
     * should be sent — it is only ever set on the proxy path. */
    headers?: Record<string, string>;
}
/** Reference TurnEngine over the Vercel AI SDK. One turn per call: tools are
 * declared WITHOUT execute functions, so generateText returns tool calls
 * without running them or looping. */
declare class AiSdkEngine$1 implements TurnEngine$1 {
    private opts;
    constructor(opts: AiSdkEngineOptions);
    resolveModel(model: string): LanguageModel;
    turn(req: TurnRequest$1): Promise<TurnResult$1>;
}

/** @deprecated Use `experimental.ai.generate`. */
declare const LlmFlowStep: typeof generate;
/** @deprecated Use `experimental.ai.GenerateOptions`. */
type LlmOptions<R> = GenerateOptions<R>;
/** @deprecated Use `experimental.ai.defineAgent`. */
declare const defineAgent: typeof defineAgent$1;
/** @deprecated Use `experimental.ai.Agent`. */
type Agent<I = any, R = any> = Agent$1<I, R>;
/** @deprecated Use `experimental.ai.AgentConfig`. */
type AgentConfig<I = any, R = any> = AgentConfig$1<I, R>;
/** @deprecated Use `experimental.ai.defineTool`. */
declare const defineTool: typeof defineTool$1;
/** @deprecated Use `experimental.ai.ToolDefinition`. */
type ToolDefinition<P = any> = ToolDefinition$1<P>;
/** @deprecated Use `experimental.ai.TurnEngine`. */
type TurnEngine = TurnEngine$1;
/** @deprecated Use `experimental.ai.TurnRequest`. */
type TurnRequest = TurnRequest$1;
/** @deprecated Use `experimental.ai.TurnResult`. */
type TurnResult = TurnResult$1;
/** @deprecated Use `experimental.ai.AgentMessage`. */
type AgentMessage = AgentMessage$1;
/** @deprecated Use `experimental.testing.ScriptedEngine`. */
declare const ScriptedEngine: typeof ScriptedEngine$1;
/** @deprecated Use `experimental.testing.ScriptedEngine`. */
type ScriptedEngine = ScriptedEngine$1;
/** @deprecated Use `experimental.testing.scriptedTurn`. */
declare const scriptedTurn: {
    text(text: string): TurnResult$1;
    toolCall(name: string, args: Record<string, unknown>, id?: string): TurnResult$1;
};
/** @deprecated The engine is chosen by the runtime; flows don't construct it. */
declare const AiSdkEngine: typeof AiSdkEngine$1;
/** @deprecated The engine is chosen by the runtime; flows don't construct it. */
type AiSdkEngine = AiSdkEngine$1;

type index_Agent<I = any, R = any> = Agent<I, R>;
type index_AgentConfig<I = any, R = any> = AgentConfig<I, R>;
type index_AgentMessage = AgentMessage;
type index_AiSdkEngine = AiSdkEngine;
declare const index_LlmFlowStep: typeof LlmFlowStep;
type index_LlmOptions<R> = LlmOptions<R>;
type index_ScriptedEngine = ScriptedEngine;
type index_ToolDefinition<P = any> = ToolDefinition<P>;
type index_TurnEngine = TurnEngine;
type index_TurnRequest = TurnRequest;
type index_TurnResult = TurnResult;
declare const index_ai: typeof ai;
declare const index_defineAgent: typeof defineAgent;
declare const index_defineTool: typeof defineTool;
declare const index_scriptedTurn: typeof scriptedTurn;
declare const index_testing: typeof testing;
declare namespace index {
  export { type index_Agent as Agent, type index_AgentConfig as AgentConfig, type index_AgentMessage as AgentMessage, type index_AiSdkEngine as AiSdkEngine, index_LlmFlowStep as LlmFlowStep, type index_LlmOptions as LlmOptions, type index_ScriptedEngine as ScriptedEngine, type index_ToolDefinition as ToolDefinition, type index_TurnEngine as TurnEngine, type index_TurnRequest as TurnRequest, type index_TurnResult as TurnResult, index_ai as ai, index_defineAgent as defineAgent, index_defineTool as defineTool, index_scriptedTurn as scriptedTurn, index_testing as testing };
}

declare const createTraceAPI: typeof createTraceAPI$1;
declare function ksuid(): string;

declare const notify: NotifyApi;

type IDWhereCondition = {
    equals?: string | null;
    notEquals?: string | null;
    oneOf?: string[] | null;
};
type StringWhereCondition = {
    startsWith?: string | null;
    endsWith?: string | null;
    oneOf?: string[] | null;
    contains?: string | null;
    equals?: string | null;
    notEquals?: string | null;
};
type BooleanWhereCondition = {
    equals?: boolean | null;
    notEquals?: boolean | null;
};
type NumberWhereCondition = {
    greaterThan?: number | null;
    greaterThanOrEquals?: number | null;
    lessThan?: number | null;
    lessThanOrEquals?: number | null;
    equals?: number | null;
    notEquals?: number | null;
};
type DurationWhereCondition = {
    greaterThan?: DurationString | null;
    greaterThanOrEquals?: DurationString | null;
    lessThan?: DurationString | null;
    lessThanOrEquals?: DurationString | null;
    equals?: DurationString | null;
    notEquals?: DurationString | null;
};
type DateWhereCondition = {
    equals?: Date | string | null;
    equalsRelative?: RelativeDateString | null;
    before?: Date | string | null;
    beforeRelative?: RelativeDateString | null;
    onOrBefore?: Date | string | null;
    after?: Date | string | null;
    afterRelative?: RelativeDateString | null;
    onOrAfter?: Date | string | null;
};
type DateQueryInput = {
    equals?: string | null;
    before?: string | null;
    onOrBefore?: string | null;
    after?: string | null;
    onOrAfter?: string | null;
};
type TimestampQueryInput = {
    before?: string | null;
    onOrBefore?: string | null;
    after?: string | null;
    onOrAfter?: string | null;
    equalsRelative?: RelativeDateString | null;
    beforeRelative?: RelativeDateString | null;
    afterRelative?: RelativeDateString | null;
};
type StringArrayWhereCondition = {
    equals?: string[] | null;
    notEquals?: string[] | null;
    any?: StringArrayQueryWhereCondition | null;
    all?: StringArrayQueryWhereCondition | null;
};
type StringArrayQueryWhereCondition = {
    equals?: string | null;
    notEquals?: string | null;
};
type NumberArrayWhereCondition = {
    equals?: number[] | null;
    notEquals?: number[] | null;
    any?: NumberArrayQueryWhereCondition | null;
    all?: NumberArrayQueryWhereCondition | null;
};
type NumberArrayQueryWhereCondition = {
    greaterThan?: number | null;
    greaterThanOrEquals?: number | null;
    lessThan?: number | null;
    lessThanOrEquals?: number | null;
    equals?: number | null;
    notEquals?: number | null;
};
type BooleanArrayWhereCondition = {
    equals?: boolean[] | null;
    notEquals?: boolean[] | null;
    any?: BooleanArrayQueryWhereCondition | null;
    all?: BooleanArrayQueryWhereCondition | null;
};
type BooleanArrayQueryWhereCondition = {
    equals?: boolean | null;
    notEquals?: boolean | null;
};
type DateArrayWhereCondition = {
    equals?: Date[] | null;
    notEquals?: Date[] | null;
    any?: DateArrayQueryWhereCondition | null;
    all?: DateArrayQueryWhereCondition | null;
};
type DateArrayQueryWhereCondition = {
    greaterThan?: Date | null;
    greaterThanOrEquals?: Date | null;
    lessThan?: Date | null;
    lessThanOrEquals?: number | null;
    equals?: Date | null;
    notEquals?: Date | null;
};
type ContextAPI = {
    headers: RequestHeaders;
    response: Response;
    isAuthenticated: boolean;
    trace: TraceAPI;
    now(): Date;
};
type Response = {
    headers: Headers;
    status?: number;
};
type PageInfo = {
    startCursor: string;
    endCursor: string;
    totalCount: number;
    hasNextPage: boolean;
    count: number;
    pageNumber?: number;
};
/**
 * Partial PageInfo for manual pagination - all fields optional with sensible defaults.
 * - count: defaults to results.length
 * - totalCount: defaults to results.length
 * - hasNextPage: defaults to false
 * - startCursor: defaults to first result's id or ""
 * - endCursor: defaults to last result's id or ""
 * - pageNumber: optional, no default
 */
type PartialPageInfo = {
    startCursor?: string;
    endCursor?: string;
    totalCount?: number;
    hasNextPage?: boolean;
    count?: number;
    pageNumber?: number;
};
/**
 * Result type for list operations with pagination info.
 * Used when returning manually paginated results from beforeQuery or afterQuery hooks.
 */
type ListResult<M> = {
    results: Array<M>;
    pageInfo: PartialPageInfo;
};
type SortDirection = "asc" | "desc" | "ASC" | "DESC";
declare class NotFoundError extends Error {
}
declare class BadRequestError$1 extends Error {
}
declare class UnknownError$1 extends Error {
}
type Errors = {
    /**
     * Returns a 404 HTTP status with an optional message.
     * This error indicates that the requested resource could not be found.
     */
    NotFound: typeof NotFoundError;
    /**
     * Returns a 400 HTTP status with an optional message.
     * This error indicates that the request made by the client is invalid or malformed.
     */
    BadRequest: typeof BadRequestError$1;
    /**
     * Returns a 500 HTTP status with an optional message.
     * This error indicates that an unexpected condition was encountered, preventing the server from fulfilling the request.
     */
    Unknown: typeof UnknownError$1;
};
type FunctionConfig = {
    /**
     * All DB calls within the function will be executed within a transaction.
     * The transaction is rolled back if the function throws an error.
     */
    dbTransaction?: boolean;
};
type FuncWithConfig<T> = T & {
    config: FunctionConfig;
};
type unit = "year" | "years" | "month" | "months" | "day" | "days" | "hour" | "hours" | "minute" | "minutes" | "second" | "seconds";
type direction = "next" | "last";
type completed = "complete";
type value = number;
type RelativeDateString = "now" | "today" | "tomorrow" | "yesterday" | `this ${unit}` | `${direction} ${unit}` | `${direction} ${value} ${unit}` | `${direction} ${value} ${completed} ${unit}`;
type dateDuration = `${number}Y${number}M${number}D` | `${number}Y${number}M` | `${number}Y${number}D` | `${number}M${number}D` | `${number}Y` | `${number}M` | `${number}D`;
type timeDuration = `${number}H${number}M${number}S` | `${number}H${number}M` | `${number}M${number}S` | `${number}H${number}S` | `${number}H` | `${number}M` | `${number}S`;
type DurationString = `P${dateDuration}T${timeDuration}` | `P${dateDuration}` | `PT${timeDuration}`;
type TaskStatus = "NEW" | "ASSIGNED" | "STARTED" | "COMPLETED" | "CANCELLED" | "DEFERRED";
type Task = {
    id: string;
    topic: string;
    status: TaskStatus;
    deferredUntil?: Date;
    createdAt: Date;
    updatedAt: Date;
    assignedToUserId?: string;
    assignedToTeam?: string;
    assignedAt?: Date;
    resolvedAt?: Date;
    flowRunId?: string;
};
type TaskCreateOptions = {
    deferredUntil?: Date;
};
type FlowRunStatus = "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED";
type FlowRunStep = {
    id: string;
    name?: string;
    status?: string;
    data?: any;
};
type FlowRun = {
    id: string;
    name: string;
    status: FlowRunStatus;
    inputs?: any;
    outputs?: any;
    steps?: FlowRunStep[];
    pendingStep?: FlowRunStep;
    createdAt?: Date;
    updatedAt?: Date;
    completedAt?: Date;
};
type FlowListOptions = {
    limit?: number;
    offset?: number;
};
type FlowListResult = {
    results: FlowRun[];
    pageInfo: {
        totalCount: number;
        hasNextPage: boolean;
    };
};
type SignedLinkOptions<Inputs = any> = {
    inputs?: Inputs;
    expiresAt?: Date;
    reusable?: boolean;
};
type SignedLinkStatus = "active" | "revoked" | "expired";
type SignedLinkRecord = {
    id: string;
    flowName: string;
    inputs: Record<string, any> | null;
    reusable: boolean;
    createdBy: string | null;
    expiresAt: Date | null;
    usedCount: number;
    revokedAt: Date | null;
    createdAt: Date;
    updatedAt: Date;
    status: SignedLinkStatus;
    url?: string;
};
type ListSignedLinksOptions = {
    status?: SignedLinkStatus;
};
type ListSignedLinksResult = {
    results: SignedLinkRecord[];
};
type SignedLinksAPI<Inputs = any> = {
    create(options?: SignedLinkOptions<Inputs>): Promise<SignedLinkRecord>;
    list(options?: ListSignedLinksOptions): Promise<ListSignedLinksResult>;
    revoke(linkId: string): Promise<SignedLinkRecord>;
};

export { ACTION_ERROR_CODES, ActionError, type ActionErrorCode, type ActionInputs, type ActionLedgerAmountGuardError, type ActionLedgerBalanceGuardError, type ActionLedgerErrorData, type ActionLedgerGuardErrorData, type ActionLedgerGuardKind, type ActionLedgerRelatedRowGuardError, type ActionPaths, type ActionValidationErrorData, ActionsAPI, type AnyToolInputs, type BooleanArrayQueryWhereCondition, type BooleanArrayWhereCondition, type BooleanWhereCondition, type ColumnBooleanFormat, type ColumnFormat, type ColumnNumberColor, type ColumnNumberFormat, type ColumnTextFormat, type ColumnValueFormat, type ContextAPI, type ContinueOptions, type DataGridOption, type DataGridSummaryBlock, type DataGridSummaryItem, type DataGridTotal, type DataGridTotals, type DateArrayQueryWhereCondition, type DateArrayWhereCondition, type DateQueryInput, type DateWhereCondition, Duration, type DurationString, type DurationWhereCondition, type EmailContent, type EmailDetail, type EmailInput, type EmailRecipientGroup, type EmailRecipients, ErrorPresets, type Errors, type ExtractStageKeys, File, type FlowConfig, type FlowConfigAPI, type FlowContext, type FlowDefinition, type FlowExternalAccessConfig, type FlowFunction, type FlowListOptions, type FlowListResult, type FlowResult, type FlowRun, type FlowRunStatus, type FlowRunStep, FlowsAPI, type FuncWithConfig, type FunctionConfig, type Hardware, type IDWhereCondition, type IngestItem, InlineFile, type IntegrationServer, type ListArgs, type ListResult, type ListSignedLinksOptions, type ListSignedLinksResult, ModelAPI, type ModuleExportsContext, type ModuleExportsFactory, NonRetriableError, type NotifyApi, type NullableHardware, type NumberArrayQueryWhereCondition, type NumberArrayWhereCondition, type NumberWhereCondition, PERMISSION_STATE, type PageInfo, type PartialPageInfo, Permissions, type Printer, type ProgressHandle, type ProgressPatch, type RateLimitConfig, type RecipientIdentity, type RecipientUser, type ReconcileArgs, type ReconcilePage, type RecordSource, type RecordState, type RedirectConfig, type RelativeDateString, RequestHeaders, type Response, RetryBackoffExponential, RetryBackoffLinear, RetryConstant, STEP_STATUS, STEP_TYPE, Signature, type SignedLinkOptions, type SignedLinkRecord, type SignedLinkStatus, type SignedLinksAPI, type SortDirection, type Step, type StepProgress, type StringArrayQueryWhereCondition, type StringArrayWhereCondition, type StringWhereCondition, type SyncDefinition, type SyncEngineHooks, type SyncEngineInternals, type SyncEngineOptions, type SyncEntityDeclaration, type SyncIngestOptions, type SyncIngestResult, type SyncModuleRef, type SyncPage, type SyncRecord, type SyncRecordOptions, type SyncStrategy, type SyncUpsertModel, type Task, TaskAPI, type TaskCreateOptions, type TaskFlowFunction, type TaskStatus, type TimelineGranularity, type TimelineItem, type TimelineItemInput, type TimelineRow, type TimestampQueryInput, type ToolAccessor, type ToolRef, type TraceAPI, type TraceAttributeValue, type TraceAttributes, type UI, type UIApiResponses, UnionAPI, type VisibilityExpression, buildModuleAPI, checkBuiltInPermissions, createChildRun, createFlowContext, createIntegrationServer, createNotifier, createToolsAPI, createTraceAPI, defineModuleExports, defineSync, index as experimental, handleFlow, handleJob, handleRequest, handleRoute, handleSubscriber, insertNewStep, isActionError, ksuid, log, notify, parseCadenceMs, registerModuleExports, runSync, runWithStatementTimeout, syncIngest, syncRecord, syncUpsert, tracing, useDatabase };