/**
 * Top-level flow definition containing metadata, configuration, and the flow structure
 */
export type OpenFlow = {
    /**
     * Short description of what this flow does
     */
    summary: string;
    /**
     * Detailed documentation for this flow
     */
    description?: string;
    value: FlowValue;
    /**
     * JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')
     */
    schema?: {
        [key: string]: unknown;
    };
    /**
     * The flow will be run with the permissions of the user with this email.
     */
    on_behalf_of_email?: string;
};
/**
 * The flow structure containing modules and optional preprocessor/failure handlers
 */
export type FlowValue = {
    /**
     * Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch
     */
    modules: Array<FlowModule>;
    /**
     * Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types
     */
    failure_module?: FlowModule;
    /**
     * Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results
     */
    preprocessor_module?: FlowModule;
    /**
     * If true, all steps run on the same worker for better performance
     */
    same_worker?: boolean;
    /**
     * Maximum number of concurrent executions of this flow
     */
    concurrent_limit?: number;
    /**
     * Expression to group concurrent executions (e.g., by user ID)
     */
    concurrency_key?: string;
    /**
     * Time window in seconds for concurrent_limit
     */
    concurrency_time_window_s?: number;
    /**
     * Delay in seconds to debounce flow executions
     */
    debounce_delay_s?: number;
    /**
     * Expression to group debounced executions
     */
    debounce_key?: string;
    /**
     * Arguments to accumulate across debounced executions
     */
    debounce_args_to_accumulate?: Array<(string)>;
    /**
     * Maximum total time in seconds that a job can be debounced
     */
    max_total_debouncing_time?: number;
    /**
     * Maximum number of times a job can be debounced
     */
    max_total_debounces_amount?: number;
    /**
     * JavaScript expression to conditionally skip the entire flow
     */
    skip_expr?: string;
    /**
     * Cache duration in seconds for flow results
     */
    cache_ttl?: number;
    cache_ignore_s3_path?: boolean;
    /**
     * If set, delete the flow job's args, result and logs after this many seconds following job completion
     */
    delete_after_secs?: number;
    /**
     * Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).
     */
    flow_env?: {
        [key: string]: unknown;
    };
    /**
     * Execution priority (higher numbers run first)
     */
    priority?: number;
    /**
     * JavaScript expression to return early from the flow
     */
    early_return?: string;
    /**
     * Whether this flow accepts chat-style input
     */
    chat_input_enabled?: boolean;
    /**
     * Sticky notes attached to the flow
     */
    notes?: Array<FlowNote>;
    /**
     * Semantic groups of modules for organizational purposes
     */
    groups?: Array<{
        /**
         * Display name for this group
         */
        summary?: string;
        /**
         * Markdown note shown below the group header
         */
        note?: string;
        /**
         * If true, this group is collapsed by default in the flow editor. UI hint only.
         */
        autocollapse?: boolean;
        /**
         * ID of the first flow module in this group (topological entry point)
         */
        start_id: string;
        /**
         * ID of the last flow module in this group (topological exit point)
         */
        end_id: string;
        /**
         * Color for the group in the flow editor
         */
        color?: string;
    }>;
};
/**
 * Retry configuration for failed module executions
 */
export type Retry = {
    /**
     * Retry with constant delay between attempts
     */
    constant?: {
        /**
         * Number of retry attempts
         */
        attempts?: number;
        /**
         * Seconds to wait between retries
         */
        seconds?: number;
    };
    /**
     * Retry with exponential backoff (delay doubles each time)
     */
    exponential?: {
        /**
         * Number of retry attempts
         */
        attempts?: number;
        /**
         * Multiplier for exponential backoff
         */
        multiplier?: number;
        /**
         * Initial delay in seconds
         */
        seconds?: number;
        /**
         * Random jitter percentage (0-100) to avoid thundering herd
         */
        random_factor?: number;
    };
    /**
     * Conditional retry based on error or result
     */
    retry_if?: {
        /**
         * JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables
         */
        expr: string;
    };
};
/**
 * Early termination condition for a module
 */
export type StopAfterIf = {
    /**
     * If true, following steps are skipped when this condition triggers
     */
    skip_if_stopped?: boolean;
    /**
     * JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop
     */
    expr: string;
    /**
     * Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised.
     */
    error_message?: string | null;
};
/**
 * A single step in a flow. Can be a script, subflow, loop, or branch
 */
export type FlowModule = {
    /**
     * Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)
     */
    id: string;
    value: FlowModuleValue;
    /**
     * Early termination condition evaluated after this step completes
     */
    stop_after_if?: StopAfterIf;
    /**
     * For loops only - early termination condition evaluated after all iterations complete
     */
    stop_after_all_iters_if?: StopAfterIf;
    /**
     * Conditionally skip this step based on previous results or flow inputs
     */
    skip_if?: {
        /**
         * JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'
         */
        expr: string;
    };
    /**
     * Delay before executing this step (in seconds or as expression)
     */
    sleep?: InputTransform;
    /**
     * Cache duration in seconds for this step's results
     */
    cache_ttl?: number;
    cache_ignore_s3_path?: boolean;
    /**
     * Maximum execution time in seconds (static value or expression)
     */
    timeout?: InputTransform;
    /**
     * If set, delete the step's args, result and logs after this many seconds following job completion
     */
    delete_after_secs?: number;
    /**
     * Short description of what this step does
     */
    summary?: string;
    /**
     * Mock configuration for testing without executing the actual step
     */
    mock?: {
        /**
         * If true, return mock value instead of executing
         */
        enabled?: boolean;
        /**
         * Value to return when mocked
         */
        return_value?: unknown;
    };
    /**
     * Configuration for approval/resume steps that wait for user input
     */
    suspend?: {
        /**
         * Number of approvals required before continuing
         */
        required_events?: number;
        /**
         * Timeout in seconds before auto-continuing or canceling
         */
        timeout?: number;
        /**
         * Form schema for collecting input when resuming
         */
        resume_form?: {
            /**
             * JSON Schema for the resume form
             */
            schema?: {
                [key: string]: unknown;
            };
        };
        /**
         * If true, only authenticated users can approve
         */
        user_auth_required?: boolean;
        /**
         * Expression or list of groups that can approve
         */
        user_groups_required?: InputTransform;
        /**
         * If true, the user who started the flow cannot approve
         */
        self_approval_disabled?: boolean;
        /**
         * If true, hide the cancel button on the approval form
         */
        hide_cancel?: boolean;
        /**
         * If true, continue flow on timeout instead of canceling
         */
        continue_on_disapprove_timeout?: boolean;
    };
    /**
     * Execution priority for this step (higher numbers run first)
     */
    priority?: number;
    /**
     * If true, flow continues even if this step fails
     */
    continue_on_error?: boolean;
    /**
     * Retry configuration if this step fails
     */
    retry?: Retry;
    /**
     * Debounce configuration for this step (OEE only)
     */
    debouncing?: {
        /**
         * Delay in seconds to debounce this step's executions across flow runs
         */
        debounce_delay_s?: number;
        /**
         * Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>
         */
        debounce_key?: string;
        /**
         * Array-type arguments to accumulate across debounced executions
         */
        debounce_args_to_accumulate?: Array<(string)>;
        /**
         * Maximum total time in seconds before forced execution
         */
        max_total_debouncing_time?: number;
        /**
         * Maximum number of debounces before forced execution
         */
        max_total_debounces_amount?: number;
    };
};
/**
 * Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs
 */
export type InputTransform = StaticTransform | JavascriptTransform | AiTransform;
/**
 * Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'
 */
export type StaticTransform = {
    /**
     * The static value. For resources, use format '$res:path/to/resource'
     */
    value?: unknown;
    type: 'static';
};
/**
 * JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value
 */
export type JavascriptTransform = {
    /**
     * JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)
     */
    expr: string;
    type: 'javascript';
};
/**
 * Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.
 */
export type AiTransform = {
    type: 'ai';
};
/**
 * Complete AI provider configuration with resource reference and model selection
 */
export type ProviderConfig = {
    /**
     * Supported AI provider types
     */
    kind: 'openai' | 'azure_openai' | 'anthropic' | 'mistral' | 'deepseek' | 'googleai' | 'groq' | 'openrouter' | 'togetherai' | 'customai' | 'aws_bedrock';
    /**
     * Resource reference in format '$res:{resource_path}' pointing to provider credentials
     */
    resource: string;
    /**
     * Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')
     */
    model: string;
};
/**
 * Conversation memory configuration
 */
export type MemoryConfig = {
    kind: 'off';
} | {
    kind: 'auto';
    /**
     * Maximum number of messages to retain in context
     */
    context_length?: number;
    /**
     * Identifier for persistent memory across agent invocations
     */
    memory_id?: string;
} | {
    kind: 'manual';
    messages: Array<{
        role: 'user' | 'assistant' | 'system';
        content: string;
    }>;
};
/**
 * The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type
 */
export type FlowModuleValue = RawScript | PathScript | PathFlow | ForloopFlow | WhileloopFlow | BranchOne | BranchAll | Identity | AiAgent;
/**
 * Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms
 */
export type RawScript = {
    /**
     * Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments
     */
    input_transforms: {
        [key: string]: InputTransform;
    };
    /**
     * The script source code. Should export a 'main' function
     */
    content: string;
    /**
     * Programming language for this script
     */
    language: 'deno' | 'bun' | 'python3' | 'go' | 'bash' | 'powershell' | 'postgresql' | 'mysql' | 'bigquery' | 'snowflake' | 'mssql' | 'oracledb' | 'graphql' | 'nativets' | 'php' | 'rust' | 'ansible' | 'csharp' | 'nu' | 'java' | 'ruby' | 'rlang' | 'duckdb' | 'mongodb' | 'groovy' | 'kotlin' | 'dart';
    /**
     * Optional path for saving this script
     */
    path?: string;
    /**
     * Lock file content for dependencies
     */
    lock?: string;
    type: 'rawscript';
    /**
     * Worker group tag for execution routing
     */
    tag?: string;
    /**
     * Maximum concurrent executions of this script
     */
    concurrent_limit?: number;
    /**
     * Time window for concurrent_limit
     */
    concurrency_time_window_s?: number;
    /**
     * Custom key for grouping concurrent executions
     */
    custom_concurrency_key?: string;
    /**
     * If true, this script is a trigger that can start the flow
     */
    is_trigger?: boolean;
    /**
     * External resources this script accesses (S3 objects, resources, etc.)
     */
    assets?: Array<{
        /**
         * Path to the asset
         */
        path: string;
        /**
         * Type of asset
         */
        kind: 's3object' | 'resource' | 'ducklake' | 'datatable' | 'volume';
        /**
         * Access level for this asset
         */
        access_type?: 'r' | 'w' | 'rw' | null;
        /**
         * Alternative access level
         */
        alt_access_type?: 'r' | 'w' | 'rw' | null;
    }>;
};
/**
 * Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code
 */
export type PathScript = {
    /**
     * Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments
     */
    input_transforms: {
        [key: string]: InputTransform;
    };
    /**
     * Path to the script in the workspace (e.g., 'f/scripts/send_email')
     */
    path: string;
    /**
     * Optional specific version hash of the script to use
     */
    hash?: string;
    type: 'script';
    /**
     * Override the script's default worker group tag
     */
    tag_override?: string;
    /**
     * If true, this script is a trigger that can start the flow
     */
    is_trigger?: boolean;
};
/**
 * Reference to an existing flow by path. Use this to call another flow as a subflow
 */
export type PathFlow = {
    /**
     * Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments
     */
    input_transforms: {
        [key: string]: InputTransform;
    };
    /**
     * Path to the flow in the workspace (e.g., 'f/flows/process_user')
     */
    path: string;
    type: 'flow';
};
/**
 * Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations
 */
export type ForloopFlow = {
    /**
     * Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'
     */
    modules: Array<FlowModule>;
    /**
     * JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'
     */
    iterator: InputTransform;
    /**
     * If true, iteration failures don't stop the loop. Failed iterations return null
     */
    skip_failures: boolean;
    type: 'forloopflow';
    /**
     * If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency
     */
    parallel?: boolean;
    /**
     * Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression
     */
    parallelism?: InputTransform;
    squash?: boolean;
};
/**
 * Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination
 */
export type WhileloopFlow = {
    /**
     * Steps to execute in each iteration. Use stop_after_if to control when the loop ends
     */
    modules: Array<FlowModule>;
    /**
     * If true, iteration failures don't stop the loop. Failed iterations return null
     */
    skip_failures: boolean;
    type: 'whileloopflow';
    /**
     * If true, iterations run concurrently (use with caution in while loops)
     */
    parallel?: boolean;
    /**
     * Maximum number of concurrent iterations when parallel=true
     */
    parallelism?: InputTransform;
    squash?: boolean;
};
/**
 * Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes
 */
export type BranchOne = {
    /**
     * Array of branches to evaluate in order. The first branch with expr evaluating to true executes
     */
    branches: Array<{
        /**
         * Short description of this branch condition
         */
        summary?: string;
        /**
         * JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins
         */
        expr: string;
        /**
         * Steps to execute if this branch's expr is true
         */
        modules: Array<FlowModule>;
    }>;
    /**
     * Steps to execute if no branch expressions match
     */
    default: Array<FlowModule>;
    type: 'branchone';
};
/**
 * Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently
 */
export type BranchAll = {
    /**
     * Array of branches that all execute (either in parallel or sequentially)
     */
    branches: Array<{
        /**
         * Short description of this branch's purpose
         */
        summary?: string;
        /**
         * If true, failure in this branch doesn't fail the entire flow
         */
        skip_failure?: boolean;
        /**
         * Steps to execute in this branch
         */
        modules: Array<FlowModule>;
    }>;
    type: 'branchall';
    /**
     * If true, all branches execute concurrently. If false, they execute sequentially
     */
    parallel?: boolean;
};
/**
 * AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task
 */
export type AiAgent = {
    /**
     * Input parameters for the AI agent mapped to their values
     */
    input_transforms: {
        /**
         * Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined
         */
        provider: {
            value: ProviderConfig;
            type: 'static';
        } | JavascriptTransform | AiTransform;
        /**
         * Output format type.
         * Valid values: 'text' (default) - plain text response, 'image' - image generation
         *
         */
        output_type: InputTransform;
        /**
         * The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax.
         */
        user_message: InputTransform;
        /**
         * System instructions that guide the AI's behavior, persona, and response style. Optional.
         */
        system_prompt?: InputTransform;
        /**
         * Boolean. If true, stream the AI response incrementally.
         * Streaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result
         *
         */
        streaming?: InputTransform;
        /**
         * Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined
         */
        memory?: {
            value: MemoryConfig;
            type: 'static';
        } | JavascriptTransform | AiTransform;
        /**
         * JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.
         * Supports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.
         * Example: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }
         *
         */
        output_schema?: InputTransform;
        /**
         * Array of file references (images or PDFs) for the AI agent.
         * Format: Array<{ bucket: string, key: string }> - S3 object references
         * Example: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]
         *
         */
        user_attachments?: InputTransform;
        /**
         * Integer. Maximum number of tokens the AI will generate in its response.
         * Range: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.
         *
         */
        max_completion_tokens?: InputTransform;
        /**
         * Float. Controls randomness/creativity of responses.
         * Range: 0.0 to 2.0 (provider-dependent)
         * - 0.0 = deterministic, focused responses
         * - 0.7 = balanced (common default)
         * - 1.0+ = more creative/random
         *
         */
        temperature?: InputTransform;
    };
    /**
     * Array of tools the agent can use. The agent decides which tools to call based on the task
     */
    tools: Array<{
        /**
         * Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')
         */
        id: string;
        /**
         * Short description of what this tool does (shown to the AI)
         */
        summary?: string;
        /**
         * The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference
         */
        value: {
            tool_type: 'flowmodule';
        } & FlowModuleValue | {
            tool_type: 'mcp';
            /**
             * Path to the MCP resource/server configuration
             */
            resource_path: string;
            /**
             * Whitelist of specific tools to include from this MCP server
             */
            include_tools?: Array<(string)>;
            /**
             * Blacklist of tools to exclude from this MCP server
             */
            exclude_tools?: Array<(string)>;
        } | {
            tool_type: 'websearch';
        };
    }>;
    type: 'aiagent';
    /**
     * If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled.
     */
    omit_output_from_conversation?: boolean;
    /**
     * If true, the agent can execute multiple tool calls in parallel
     */
    parallel?: boolean;
};
/**
 * Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder
 */
export type Identity = {
    type: 'identity';
    /**
     * If true, marks this as a flow identity (special handling)
     */
    flow?: boolean;
};
export type FlowStatus = {
    step: number;
    modules: Array<FlowStatusModule>;
    user_states?: unknown;
    preprocessor_module?: FlowStatusModule;
    failure_module: FlowStatusModule & {
        parent_module?: string;
    };
    retry?: {
        fail_count?: number;
        failed_jobs?: Array<(string)>;
    };
};
export type FlowStatusModule = {
    type: 'WaitingForPriorSteps' | 'WaitingForEvents' | 'WaitingForExecutor' | 'InProgress' | 'Success' | 'Failure';
    id?: string;
    job?: string;
    count?: number;
    progress?: number;
    iterator?: {
        index?: number;
        itered?: Array<unknown>;
        itered_len?: number;
        args?: unknown;
    };
    flow_jobs?: Array<(string)>;
    flow_jobs_success?: Array<(boolean)>;
    flow_jobs_duration?: {
        started_at?: Array<(string)>;
        duration_ms?: Array<(number)>;
    };
    branch_chosen?: {
        type: 'branch' | 'default';
        branch?: number;
    };
    branchall?: {
        branch: number;
        len: number;
    };
    approvers?: Array<{
        resume_id: number;
        approver: string;
    }>;
    failed_retries?: Array<(string)>;
    skipped?: boolean;
    agent_actions?: Array<({
        job_id: string;
        function_name: string;
        type: 'tool_call';
        module_id: string;
    } | {
        call_id: string;
        function_name: string;
        resource_path: string;
        type: 'mcp_tool_call';
        arguments?: {
            [key: string]: unknown;
        };
    } | {
        type: 'web_search';
    } | {
        type: 'message';
    })>;
    agent_actions_success?: Array<(boolean)>;
};
/**
 * A sticky note attached to a flow for documentation and annotation
 */
export type FlowNote = {
    /**
     * Unique identifier for the note
     */
    id: string;
    /**
     * Content of the note
     */
    text: string;
    /**
     * Position of the note in the flow editor
     */
    position?: {
        /**
         * X coordinate
         */
        x: number;
        /**
         * Y coordinate
         */
        y: number;
    };
    /**
     * Size of the note in the flow editor
     */
    size?: {
        /**
         * Width in pixels
         */
        width: number;
        /**
         * Height in pixels
         */
        height: number;
    };
    /**
     * Color of the note (e.g., "yellow", "#ffff00")
     */
    color: string;
    /**
     * Type of note - 'free' for standalone notes, 'group' for notes that group other nodes
     */
    type: 'free' | 'group';
    /**
     * Whether the note is locked and cannot be edited or moved
     */
    locked?: boolean;
    /**
     * For group notes, the IDs of nodes contained within this group
     */
    contained_node_ids?: Array<(string)>;
};
export type CiTestResult = {
    test_script_path: string;
    job_id?: string | null;
    status?: string | null;
    started_at?: string | null;
};
/**
 * Health status response (cached with 5s TTL)
 */
export type HealthStatusResponse = {
    /**
     * Overall health status
     */
    status: 'healthy' | 'degraded' | 'unhealthy';
    /**
     * Timestamp when the health check was actually performed (not cache return time)
     */
    checked_at: string;
    /**
     * Whether the database is reachable
     */
    database_healthy: boolean;
    /**
     * Number of workers that pinged within last 5 minutes
     */
    workers_alive: number;
};
/**
 * Detailed health status response (always fresh, no caching)
 */
export type DetailedHealthResponse = {
    /**
     * Overall health status
     */
    status: 'healthy' | 'degraded' | 'unhealthy';
    /**
     * Timestamp when the health check was performed
     */
    checked_at: string;
    /**
     * Server version (e.g., "OEE 1.615.3")
     */
    version: string;
    checks: HealthChecks;
};
/**
 * Detailed health checks
 */
export type HealthChecks = {
    database: DatabaseHealth;
    /**
     * Worker status (null if database is unreachable)
     */
    workers?: WorkersHealth | null;
    /**
     * Queue status (null if database is unreachable)
     */
    queue?: QueueHealth | null;
    readiness: ReadinessHealth;
};
/**
 * Database health status
 */
export type DatabaseHealth = {
    /**
     * Whether the database is reachable
     */
    healthy: boolean;
    /**
     * Database query latency in milliseconds
     */
    latency_ms: number;
    pool: PoolStats;
};
/**
 * Database connection pool statistics
 */
export type PoolStats = {
    /**
     * Current number of connections in the pool
     */
    size: number;
    /**
     * Number of idle connections
     */
    idle: number;
    /**
     * Maximum number of connections allowed
     */
    max_connections: number;
};
/**
 * Workers health status
 */
export type WorkersHealth = {
    /**
     * Whether any workers are active
     */
    healthy: boolean;
    /**
     * Number of active workers (pinged in last 5 minutes)
     */
    active_count: number;
    /**
     * List of active worker groups
     */
    worker_groups: Array<(string)>;
    /**
     * Minimum required worker version
     */
    min_version: string;
    /**
     * List of active worker versions
     */
    versions: Array<(string)>;
    /**
     * Distinct job isolation modes reported by live workers. `nsjail` means the worker both asked for nsjail sandboxing and has a working nsjail binary; `unshare` is PID-namespace isolation only; `none` means jobs run with no process isolation; `unknown` is a worker that reported no mode. Sorted for stability across polls.
     */
    job_isolation: Array<('nsjail' | 'unshare' | 'none' | 'unknown')>;
    /**
     * Number of live workers running with no process isolation (reported `none`, or nothing at all).
     */
    workers_without_isolation: number;
};
/**
 * Job queue status
 */
export type QueueHealth = {
    /**
     * Number of pending jobs in the queue
     */
    pending_jobs: number;
    /**
     * Number of currently running jobs
     */
    running_jobs: number;
};
/**
 * Server readiness status
 */
export type ReadinessHealth = {
    /**
     * Whether the server is ready to accept requests
     */
    healthy: boolean;
};
/**
 * Configuration for auto-inviting users to the workspace
 */
export type AutoInviteConfig = {
    enabled?: boolean;
    domain?: string;
    /**
     * If true, auto-invited users are added as operators. If false, they are added as developers.
     */
    operator?: boolean;
    mode?: 'invite' | 'add';
    instance_groups?: Array<(string)>;
    instance_groups_roles?: {
        [key: string]: (string);
    };
};
/**
 * Configuration for the workspace error handler
 */
export type ErrorHandlerConfig = {
    /**
     * Path to the error handler script or flow
     */
    path?: string;
    extra_args?: ScriptArgs;
    muted_on_cancel?: boolean;
    muted_on_user_path?: boolean;
};
/**
 * Configuration for the workspace success handler
 */
export type SuccessHandlerConfig = {
    /**
     * Path to the success handler script or flow
     */
    path?: string;
    extra_args?: ScriptArgs;
};
/**
 * Request body for editing the workspace error handler. Accepts both new grouped format and legacy flat format for backward compatibility.
 */
export type EditErrorHandler = EditErrorHandlerNew | EditErrorHandlerLegacy;
/**
 * New grouped format for editing error handler
 */
export type EditErrorHandlerNew = {
    /**
     * Path to the error handler script or flow
     */
    path?: string;
    extra_args?: ScriptArgs;
    muted_on_cancel?: boolean;
    muted_on_user_path?: boolean;
};
/**
 * Legacy flat format for editing error handler (deprecated, use new format)
 */
export type EditErrorHandlerLegacy = {
    /**
     * Path to the error handler script or flow
     */
    error_handler?: string;
    error_handler_extra_args?: ScriptArgs;
    error_handler_muted_on_cancel?: boolean;
};
/**
 * Request body for editing the workspace success handler. Accepts both new grouped format and legacy flat format for backward compatibility.
 */
export type EditSuccessHandler = EditSuccessHandlerNew | EditSuccessHandlerLegacy;
/**
 * New grouped format for editing success handler
 */
export type EditSuccessHandlerNew = {
    /**
     * Path to the success handler script or flow
     */
    path?: string;
    extra_args?: ScriptArgs;
};
/**
 * Legacy flat format for editing success handler (deprecated, use new format)
 */
export type EditSuccessHandlerLegacy = {
    /**
     * Path to the success handler script or flow
     */
    success_handler?: string;
    success_handler_extra_args?: ScriptArgs;
};
export type VaultSettings = {
    /**
     * HashiCorp Vault server address (e.g., https://vault.company.com:8200)
     */
    address: string;
    /**
     * KV v2 secrets engine mount path (e.g., orvanta)
     */
    mount_path: string;
    /**
     * Vault JWT auth role name for Orvanta (optional, if not provided token auth is used)
     */
    jwt_role?: string;
    /**
     * Vault Enterprise namespace (optional)
     */
    namespace?: string;
    /**
     * Static Vault token for testing/development (optional, if provided this is used instead of JWT authentication)
     */
    token?: string;
    /**
     * Skip TLS certificate verification when connecting to Vault. Only use for self-signed certificates in development environments.
     */
    skip_ssl_verify?: boolean;
};
export type AzureKeyVaultSettings = {
    /**
     * Azure Key Vault URL (e.g., https://myvault.vault.azure.net)
     */
    vault_url: string;
    /**
     * Azure AD tenant ID
     */
    tenant_id: string;
    /**
     * Azure AD application (client) ID
     */
    client_id: string;
    /**
     * Azure AD client secret. Optional — when omitted, the integration falls back to Azure Workload Identity Federation, exchanging the Kubernetes-projected service-account JWT at AZURE_FEDERATED_TOKEN_FILE for an access token (no long-lived secret stored).
     */
    client_secret?: string;
    /**
     * Static Bearer token for testing/development (optional, if provided this is used instead of OAuth2 authentication)
     */
    token?: string;
};
export type AwsSecretsManagerSettings = {
    /**
     * AWS region (e.g., us-east-1)
     */
    region: string;
    /**
     * AWS Access Key ID (optional, uses default credential chain if not provided)
     */
    access_key_id?: string;
    /**
     * AWS Secret Access Key (optional)
     */
    secret_access_key?: string;
    /**
     * Custom endpoint URL for testing (e.g., LocalStack)
     */
    endpoint_url?: string;
    /**
     * Prefix for secret names (e.g., orvanta/)
     */
    prefix?: string;
};
export type SecretMigrationFailure = {
    /**
     * Workspace ID where the secret is located
     */
    workspace_id: string;
    /**
     * Path of the secret that failed to migrate
     */
    path: string;
    /**
     * Error message
     */
    error: string;
};
export type SecretMigrationReport = {
    /**
     * Total number of secrets found
     */
    total_secrets: number;
    /**
     * Number of secrets successfully migrated
     */
    migrated_count: number;
    /**
     * Number of secrets that failed to migrate
     */
    failed_count: number;
    /**
     * Details of any failures encountered during migration
     */
    failures: Array<SecretMigrationFailure>;
};
export type JwksResponse = {
    /**
     * Array of JSON Web Keys for JWT verification
     */
    keys: Array<{
        [key: string]: unknown;
    }>;
};
export type FlowConversation = {
    /**
     * Unique identifier for the conversation
     */
    id: string;
    /**
     * The workspace ID where the conversation belongs
     */
    workspace_id: string;
    /**
     * Path of the flow this conversation is for
     */
    flow_path: string;
    /**
     * Optional title for the conversation
     */
    title?: string | null;
    /**
     * When the conversation was created
     */
    created_at: string;
    /**
     * When the conversation was last updated
     */
    updated_at: string;
    /**
     * Username who created the conversation
     */
    created_by: string;
};
export type FlowConversationMessage = {
    /**
     * Unique identifier for the message
     */
    id: string;
    /**
     * The conversation this message belongs to
     */
    conversation_id: string;
    /**
     * Type of the message
     */
    message_type: 'user' | 'assistant' | 'system' | 'tool';
    /**
     * The message content
     */
    content: string;
    /**
     * Associated job ID if this message came from a flow run
     */
    job_id?: string | null;
    /**
     * When the message was created
     */
    created_at: string;
    /**
     * Monotonic cursor assigned when the message is inserted
     */
    created_seq: number;
    /**
     * The step name that produced that message
     */
    step_name?: string;
    /**
     * Whether the message is a success
     */
    success?: boolean;
};
export type EndpointTool = {
    /**
     * The tool name/operation ID
     */
    name: string;
    /**
     * Short description of the tool
     */
    description: string;
    /**
     * Detailed instructions for using the tool
     */
    instructions: string;
    /**
     * API endpoint path
     */
    path: string;
    /**
     * HTTP method (GET, POST, etc.)
     */
    method: string;
    /**
     * JSON schema for path parameters
     */
    path_params_schema?: {
        [key: string]: unknown;
    } | null;
    /**
     * JSON schema for query parameters
     */
    query_params_schema?: {
        [key: string]: unknown;
    } | null;
    /**
     * JSON schema for request body
     */
    body_schema?: {
        [key: string]: unknown;
    } | null;
};
export type AIProvider = 'openai' | 'azure_openai' | 'anthropic' | 'mistral' | 'deepseek' | 'googleai' | 'groq' | 'openrouter' | 'togetherai' | 'aws_bedrock' | 'customai';
export type GitSyncObjectType = 'script' | 'flow' | 'bpmnflow' | 'dmndecision' | 'app' | 'folder' | 'resource' | 'variable' | 'secret' | 'resourcetype' | 'schedule' | 'user' | 'group' | 'trigger' | 'settings' | 'key' | 'workspacedependencies';
export type AIProviderModel = {
    model: string;
    provider: AIProvider;
};
export type AIProviderConfig = {
    resource_path: string;
    models: Array<(string)>;
};
export type AIConfig = {
    providers?: {
        [key: string]: AIProviderConfig;
    };
    default_model?: AIProviderModel;
    code_completion_model?: AIProviderModel;
    custom_prompts?: {
        [key: string]: (string);
    };
    max_tokens_per_model?: {
        [key: string]: (number);
    };
};
export type InstanceAIProviderSummary = {
    provider: AIProvider;
    models: Array<(string)>;
};
export type InstanceAISummary = {
    providers: Array<InstanceAIProviderSummary>;
    default_model?: AIProviderModel;
    code_completion_model?: AIProviderModel;
};
export type Alert = {
    name: string;
    tags_to_monitor: Array<(string)>;
    jobs_num_threshold: number;
    alert_cooldown_seconds: number;
    alert_time_threshold_seconds: number;
};
export type Configs = {
    alerts?: Array<Alert>;
} | null;
export type WorkspaceDependencies = {
    id: number;
    archived: boolean;
    name?: string;
    description?: string;
    content: string;
    language: ScriptLang;
    workspace_id: string;
    created_at: string;
};
export type NewWorkspaceDependencies = {
    workspace_id: string;
    language: ScriptLang;
    name?: string;
    description?: string;
    content: string;
};
export type Script = {
    workspace_id?: string;
    hash: string;
    path: string;
    /**
     * The first element is the direct parent of the script, the second is the parent of the first, etc
     *
     */
    parent_hashes?: Array<(string)>;
    summary: string;
    description: string;
    content: string;
    created_by: string;
    created_at: string;
    archived: boolean;
    schema?: {
        [key: string]: unknown;
    };
    deleted: boolean;
    is_template: boolean;
    extra_perms: {
        [key: string]: (boolean);
    };
    lock?: string;
    lock_error_logs?: string;
    language: ScriptLang;
    kind: 'script' | 'failure' | 'trigger' | 'command' | 'approval' | 'preprocessor';
    starred: boolean;
    tag?: string;
    has_draft?: boolean;
    draft_only?: boolean;
    envs?: Array<(string)>;
    concurrent_limit?: number;
    concurrency_time_window_s?: number;
    concurrency_key?: string;
    debounce_key?: string;
    debounce_delay_s?: number;
    debounce_args_to_accumulate?: Array<(string)>;
    max_total_debouncing_time?: number;
    max_total_debounces_amount?: number;
    cache_ttl?: number;
    dedicated_worker?: boolean;
    ws_error_handler_muted?: boolean;
    priority?: number;
    restart_unless_cancelled?: boolean;
    timeout?: number;
    /**
     * If set, delete the job's args, result and logs after this many seconds following job completion
     */
    delete_after_secs?: number;
    visible_to_runner_only?: boolean;
    auto_kind?: string;
    codebase?: string;
    has_preprocessor: boolean;
    on_behalf_of_email?: string;
    /**
     * Additional script modules keyed by relative file path
     */
    modules?: {
        [key: string]: ScriptModule;
    } | null;
    labels?: Array<(string)>;
};
export type NewScript = {
    path: string;
    parent_hash?: string;
    summary: string;
    description?: string;
    content: string;
    schema?: {
        [key: string]: unknown;
    };
    is_template?: boolean;
    lock?: string;
    language: ScriptLang;
    kind?: 'script' | 'failure' | 'trigger' | 'command' | 'approval' | 'preprocessor';
    tag?: string;
    draft_only?: boolean;
    envs?: Array<(string)>;
    concurrent_limit?: number;
    concurrency_time_window_s?: number;
    cache_ttl?: number;
    cache_ignore_s3_path?: boolean;
    dedicated_worker?: boolean;
    ws_error_handler_muted?: boolean;
    priority?: number;
    restart_unless_cancelled?: boolean;
    timeout?: number;
    /**
     * If set, delete the job's args, result and logs after this many seconds following job completion
     */
    delete_after_secs?: number;
    deployment_message?: string;
    concurrency_key?: string;
    debounce_key?: string;
    debounce_delay_s?: number;
    debounce_args_to_accumulate?: Array<(string)>;
    max_total_debouncing_time?: number;
    max_total_debounces_amount?: number;
    visible_to_runner_only?: boolean;
    auto_kind?: string;
    codebase?: string;
    has_preprocessor?: boolean;
    on_behalf_of_email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of_email value instead of overwriting it.
     */
    preserve_on_behalf_of?: boolean;
    assets?: Array<{
        path: string;
        kind: AssetKind;
        access_type?: 'r' | 'w' | 'rw';
        alt_access_type?: 'r' | 'w' | 'rw';
    }>;
    /**
     * Additional script modules keyed by relative file path
     */
    modules?: {
        [key: string]: ScriptModule;
    } | null;
    labels?: Array<(string)>;
};
export type NewScriptWithDraft = NewScript & {
    draft?: NewScript;
    hash: string;
};
export type ScriptHistory = {
    script_hash: string;
    deployment_msg?: string;
};
/**
 * The arguments to pass to the script or flow
 */
export type ScriptArgs = {
    [key: string]: unknown;
};
export type Input = {
    id: string;
    name: string;
    created_by: string;
    created_at: string;
    is_public: boolean;
    success?: boolean;
};
export type CreateInput = {
    name: string;
    args: {
        [key: string]: unknown;
    };
};
export type UpdateInput = {
    id: string;
    name: string;
    is_public: boolean;
};
export type RunnableType = 'ScriptHash' | 'ScriptPath' | 'FlowPath';
export type QueuedJob = {
    workspace_id?: string;
    id: string;
    parent_job?: string;
    created_by?: string;
    created_at?: string;
    started_at?: string;
    scheduled_for?: string;
    running: boolean;
    script_path?: string;
    script_hash?: string;
    args?: ScriptArgs;
    logs?: string;
    raw_code?: string;
    canceled: boolean;
    canceled_by?: string;
    canceled_reason?: string;
    last_ping?: string;
    job_kind: 'script' | 'preview' | 'dependencies' | 'flowdependencies' | 'appdependencies' | 'flow' | 'flowpreview' | 'script_hub' | 'identity' | 'deploymentcallback' | 'singlestepflow' | 'flowscript' | 'flownode' | 'appscript' | 'aiagent' | 'unassigned_script' | 'unassigned_flow' | 'unassigned_singlestepflow';
    schedule_path?: string;
    /**
     * The user (u/userfoo) or group (g/groupfoo) whom
     * the execution of this script will be permissioned_as and by extension its DT_TOKEN.
     *
     */
    permissioned_as: string;
    flow_status?: FlowStatus;
    code_flow_status?: WorkflowStatus;
    raw_flow?: FlowValue;
    is_flow_step: boolean;
    language?: ScriptLang;
    email: string;
    visible_to_owner: boolean;
    mem_peak?: number;
    tag: string;
    priority?: number;
    self_wait_time_ms?: number;
    aggregate_wait_time_ms?: number;
    suspend?: number;
    preprocessed?: boolean;
    worker?: string;
};
export type CompletedJob = {
    workspace_id?: string;
    id: string;
    parent_job?: string;
    created_by: string;
    created_at: string;
    started_at: string;
    completed_at?: string;
    duration_ms: number;
    success: boolean;
    script_path?: string;
    script_hash?: string;
    args?: ScriptArgs;
    result?: unknown;
    logs?: string;
    deleted?: boolean;
    raw_code?: string;
    canceled: boolean;
    canceled_by?: string;
    canceled_reason?: string;
    job_kind: 'script' | 'preview' | 'dependencies' | 'flow' | 'flowdependencies' | 'appdependencies' | 'flowpreview' | 'script_hub' | 'identity' | 'deploymentcallback' | 'singlestepflow' | 'flowscript' | 'flownode' | 'appscript' | 'aiagent' | 'unassigned_script' | 'unassigned_flow' | 'unassigned_singlestepflow';
    schedule_path?: string;
    /**
     * The user (u/userfoo) or group (g/groupfoo) whom
     * the execution of this script will be permissioned_as and by extension its DT_TOKEN.
     *
     */
    permissioned_as: string;
    flow_status?: FlowStatus;
    code_flow_status?: WorkflowStatus;
    raw_flow?: FlowValue;
    is_flow_step: boolean;
    language?: ScriptLang;
    is_skipped: boolean;
    email: string;
    visible_to_owner: boolean;
    mem_peak?: number;
    tag: string;
    priority?: number;
    labels?: Array<(string)>;
    self_wait_time_ms?: number;
    aggregate_wait_time_ms?: number;
    preprocessed?: boolean;
    worker?: string;
};
/**
 * Completed job with full data for export/import operations
 */
export type ExportableCompletedJob = {
    id: string;
    parent_job?: string;
    created_by: string;
    created_at: string;
    started_at?: string;
    completed_at?: string;
    duration_ms?: number;
    script_path?: string;
    script_hash?: string;
    /**
     * Full job arguments without size restrictions
     */
    args?: {
        [key: string]: unknown;
    };
    /**
     * Full job result without size restrictions
     */
    result?: {
        [key: string]: unknown;
    };
    /**
     * Complete job logs from v2_job table
     */
    logs?: string;
    raw_code?: string;
    raw_lock?: string;
    canceled_by?: string;
    canceled_reason?: string;
    job_kind: 'script' | 'preview' | 'dependencies' | 'flow' | 'flowdependencies' | 'appdependencies' | 'flowpreview' | 'script_hub' | 'identity' | 'deploymentcallback' | 'singlestepflow' | 'flowscript' | 'flownode' | 'appscript' | 'aiagent' | 'unassigned_script' | 'unassigned_flow' | 'unassigned_singlestepflow';
    /**
     * Trigger path for the job (replaces schedule_path)
     */
    trigger?: string;
    trigger_kind?: 'webhook' | 'http' | 'websocket' | 'kafka' | 'email' | 'nats' | 'schedule' | 'app' | 'ui' | 'postgres' | 'sqs' | 'gcp';
    permissioned_as: string;
    permissioned_as_email?: string;
    /**
     * Flow status from v2_job_status table
     */
    flow_status?: {
        [key: string]: unknown;
    };
    code_flow_status?: {
        [key: string]: unknown;
    };
    raw_flow?: {
        [key: string]: unknown;
    };
    is_flow_step?: boolean;
    language?: ScriptLang;
    is_skipped?: boolean;
    email: string;
    visible_to_owner: boolean;
    mem_peak?: number;
    tag?: string;
    priority?: number;
    labels?: Array<(string)>;
    same_worker?: boolean;
    flow_step_id?: string;
    flow_innermost_root_job?: string;
    concurrent_limit?: number;
    concurrency_time_window_s?: number;
    timeout?: number;
    cache_ttl?: number;
    self_wait_time_ms?: number;
    aggregate_wait_time_ms?: number;
    preprocessed?: boolean;
    worker?: string;
    /**
     * Actual job status from database
     */
    status?: string;
};
/**
 * Queued job with full data for export/import operations
 */
export type ExportableQueuedJob = {
    id: string;
    parent_job?: string;
    created_by: string;
    created_at: string;
    started_at?: string;
    scheduled_for?: string;
    script_path?: string;
    script_hash?: string;
    /**
     * Full job arguments without size restrictions
     */
    args?: {
        [key: string]: unknown;
    };
    /**
     * Complete job logs from v2_job table
     */
    logs?: string;
    raw_code?: string;
    raw_lock?: string;
    canceled_by?: string;
    canceled_reason?: string;
    job_kind: 'script' | 'preview' | 'dependencies' | 'flowdependencies' | 'appdependencies' | 'flow' | 'flowpreview' | 'script_hub' | 'identity' | 'deploymentcallback' | 'singlestepflow' | 'flowscript' | 'flownode' | 'appscript' | 'aiagent' | 'unassigned_script' | 'unassigned_flow' | 'unassigned_singlestepflow';
    /**
     * Trigger path for the job (replaces schedule_path)
     */
    trigger?: string;
    trigger_kind?: 'webhook' | 'http' | 'websocket' | 'kafka' | 'email' | 'nats' | 'schedule' | 'app' | 'ui' | 'postgres' | 'sqs' | 'gcp';
    permissioned_as: string;
    permissioned_as_email?: string;
    /**
     * Flow status from v2_job_status table
     */
    flow_status?: {
        [key: string]: unknown;
    };
    code_flow_status?: {
        [key: string]: unknown;
    };
    raw_flow?: {
        [key: string]: unknown;
    };
    is_flow_step?: boolean;
    language?: ScriptLang;
    email: string;
    visible_to_owner: boolean;
    mem_peak?: number;
    tag?: string;
    priority?: number;
    labels?: Array<(string)>;
    same_worker?: boolean;
    flow_step_id?: string;
    flow_innermost_root_job?: string;
    concurrent_limit?: number;
    concurrency_time_window_s?: number;
    timeout?: number;
    cache_ttl?: number;
    self_wait_time_ms?: number;
    aggregate_wait_time_ms?: number;
    preprocessed?: boolean;
    suspend?: number;
    suspend_until?: string;
};
export type ObscuredJob = {
    typ?: string;
    started_at?: string;
    duration_ms?: number;
};
export type Job = CompletedJob & {
    type?: 'CompletedJob';
} | QueuedJob & {
    type?: 'QueuedJob';
};
export type User = {
    email: string;
    username: string;
    is_admin: boolean;
    name?: string;
    is_super_admin: boolean;
    created_at: string;
    operator: boolean;
    disabled: boolean;
    groups?: Array<(string)>;
    folders: Array<(string)>;
    folders_owners: Array<(string)>;
    added_via?: (UserSource) | null;
    is_service_account?: boolean;
};
export type UserSource = {
    /**
     * How the user was added to the workspace
     */
    source: 'domain' | 'instance_group' | 'manual';
    /**
     * The domain used for auto-invite (when source is 'domain')
     */
    domain?: string;
    /**
     * The instance group name (when source is 'instance_group')
     */
    group?: string;
};
export type UserUsage = {
    email?: string;
    executions?: number;
};
export type Login = {
    email: string;
    password: string;
};
export type PasswordResetResponse = {
    message: string;
};
export type EditWorkspaceUser = {
    is_admin?: boolean;
    operator?: boolean;
    disabled?: boolean;
};
export type OffboardAffectedPaths = {
    scripts?: Array<(string)>;
    flows?: Array<(string)>;
    apps?: Array<(string)>;
    resources?: Array<(string)>;
    variables?: Array<(string)>;
    schedules?: Array<(string)>;
    triggers?: {
        [key: string]: Array<(string)>;
    };
};
export type OffboardPreview = {
    /**
     * Objects under u/{username}/ that will be reassigned
     */
    owned: OffboardAffectedPaths;
    /**
     * Objects not under the user's path but that execute on behalf of this user (permissioned_as/on_behalf_of will be updated)
     */
    executing_on_behalf: OffboardAffectedPaths;
    /**
     * Scripts/flows/apps/resources whose content or value references this user's paths (may break after reassignment)
     */
    referencing: OffboardAffectedPaths;
    /**
     * Tokens owned by this user (will be deleted)
     */
    tokens: Array<OffboardTokenInfo>;
    /**
     * HTTP triggers under the user's path (webhook URLs will change)
     */
    http_triggers: number;
    /**
     * Email triggers under the user's path (email addresses will change)
     */
    email_triggers: number;
};
export type OffboardTokenInfo = {
    label: string;
    scopes: Array<(string)>;
    expiration?: string;
};
export type OffboardRequest = {
    /**
     * Target for reassignment: 'u/{username}' or 'f/{folder}'
     */
    reassign_to: string;
    /**
     * Required when reassign_to is a folder. The username whose identity will be used as permissioned_as for schedules and triggers.
     */
    new_on_behalf_of_user?: string;
    /**
     * Whether to also remove the user from the workspace
     */
    delete_user?: boolean;
};
export type OffboardResponse = {
    /**
     * List of path conflicts that block the offboarding. Empty on success.
     */
    conflicts?: Array<(string)>;
    summary?: OffboardSummary;
};
export type OffboardSummary = {
    scripts_reassigned: number;
    flows_reassigned: number;
    apps_reassigned: number;
    resources_reassigned: number;
    variables_reassigned: number;
    schedules_reassigned: number;
    triggers_reassigned: number;
    drafts_deleted: number;
};
export type GlobalOffboardPreview = {
    workspaces: Array<WorkspaceOffboardPreview>;
};
export type WorkspaceOffboardPreview = {
    workspace_id: string;
    username: string;
    preview: OffboardPreview;
};
export type GlobalOffboardRequest = {
    /**
     * Map of workspace_id to reassignment config
     */
    reassignments?: {
        [key: string]: WorkspaceReassignment;
    };
    /**
     * Whether to also remove the user from the instance
     */
    delete_user?: boolean;
};
export type WorkspaceReassignment = {
    /**
     * Target: 'u/{username}' or 'f/{folder}'
     */
    reassign_to: string;
    /**
     * Required when reassign_to is a folder. Username to use as permissioned_as.
     */
    new_on_behalf_of_user?: string;
};
export type TruncatedToken = {
    label?: string;
    expiration?: string;
    token_prefix: string;
    created_at: string;
    last_used_at: string;
    scopes?: Array<(string)>;
    email?: string;
    workspace_id?: string;
};
export type ExternalJwtToken = {
    jwt_hash: number;
    email: string;
    username: string;
    is_admin: boolean;
    is_operator: boolean;
    workspace_id?: string;
    label?: string;
    scopes?: Array<(string)>;
    last_used_at: string;
};
export type NewToken = {
    label?: string;
    expiration?: string;
    scopes?: Array<(string)>;
    workspace_id?: string;
};
export type NewTokenImpersonate = {
    label?: string;
    expiration?: string;
    impersonate_email: string;
    workspace_id?: string;
};
export type SamlConfig = {
    configured: boolean;
    enabled: boolean;
    idp_entity_id?: string;
    single_sign_on_service_url?: string;
    name_id_format: string;
    sp_entity_id: string;
    acs_url: string;
    /**
     * whether unsolicited (IdP-initiated) SAML responses are accepted. false is the default and the secure posture — see SamlConfigRequest.allow_idp_initiated.
     */
    allow_idp_initiated: boolean;
};
export type SamlConfigRequest = {
    /**
     * URL to fetch the IdP's SAML metadata from (fetched server-side, SSRF-guarded). Provide this or idp_metadata_xml.
     */
    idp_metadata_url?: string;
    /**
     * the IdP's SAML metadata XML, pasted directly. Provide this or idp_metadata_url.
     */
    idp_metadata_xml?: string;
    name_id_format?: string;
    enabled: boolean;
    /**
     * accept unsolicited (IdP-initiated) SAML responses, e.g. from an Okta "My Apps" or Entra app-launcher tile. Defaults to false when omitted. Unsolicited responses carry no InResponseTo, so they cannot be bound to a login this SP started and remain exposed to login-CSRF / session fixation (#589) — enable only if your IdP offers no SP-initiated entry point.
     */
    allow_idp_initiated?: boolean;
};
export type ListableVariable = {
    workspace_id: string;
    path: string;
    value?: string;
    is_secret: boolean;
    description?: string;
    account?: number;
    is_oauth?: boolean;
    extra_perms: {
        [key: string]: (boolean);
    };
    is_expired?: boolean;
    refresh_error?: string;
    is_linked?: boolean;
    is_refreshed?: boolean;
    expires_at?: string;
    labels?: Array<(string)>;
    ws_specific?: boolean;
};
export type ContextualVariable = {
    name: string;
    value: string;
    description: string;
    is_custom: boolean;
};
export type CreateVariable = {
    /**
     * The path to the variable
     */
    path: string;
    /**
     * The value of the variable
     */
    value: string;
    /**
     * Whether the variable is a secret
     */
    is_secret: boolean;
    /**
     * The description of the variable
     */
    description: string;
    /**
     * The account identifier
     */
    account?: number;
    /**
     * Whether the variable is an OAuth variable
     */
    is_oauth?: boolean;
    /**
     * The expiration date of the variable
     */
    expires_at?: string;
    labels?: Array<(string)>;
    ws_specific?: boolean;
};
export type EditVariable = {
    /**
     * The path to the variable
     */
    path?: string;
    /**
     * The new value of the variable
     */
    value?: string;
    /**
     * Whether the variable is a secret
     */
    is_secret?: boolean;
    /**
     * The new description of the variable
     */
    description?: string;
    labels?: Array<(string)>;
    ws_specific?: boolean;
};
export type AuditLog = {
    workspace_id: string;
    id: number;
    timestamp: string;
    username: string;
    operation: 'jobs.run' | 'jobs.run.script' | 'jobs.run.preview' | 'jobs.run.flow' | 'jobs.run.flow_preview' | 'jobs.run.script_hub' | 'jobs.run.dependencies' | 'jobs.run.identity' | 'jobs.run.noop' | 'jobs.flow_dependencies' | 'jobs' | 'jobs.cancel' | 'jobs.force_cancel' | 'jobs.disapproval' | 'jobs.delete' | 'account.delete' | 'ai.request' | 'resources.create' | 'resources.update' | 'resources.delete' | 'resource_types.create' | 'resource_types.update' | 'resource_types.delete' | 'schedule.create' | 'schedule.setenabled' | 'schedule.edit' | 'schedule.delete' | 'scripts.create' | 'scripts.update' | 'scripts.archive' | 'scripts.delete' | 'users.create' | 'users.delete' | 'users.update' | 'users.login' | 'users.login_failure' | 'users.logout' | 'users.accept_invite' | 'users.decline_invite' | 'users.token.create' | 'users.token.delete' | 'users.add_to_workspace' | 'users.add_global' | 'users.setpassword' | 'users.impersonate' | 'users.leave_workspace' | 'oauth.login' | 'oauth.login_failure' | 'oauth.signup' | 'variables.create' | 'variables.delete' | 'variables.update' | 'flows.create' | 'flows.update' | 'flows.delete' | 'flows.archive' | 'apps.create' | 'apps.update' | 'apps.delete' | 'folder.create' | 'folder.update' | 'folder.delete' | 'folder.add_owner' | 'folder.remove_owner' | 'group.create' | 'group.delete' | 'group.edit' | 'group.adduser' | 'group.removeuser' | 'igroup.create' | 'igroup.delete' | 'igroup.adduser' | 'igroup.removeuser' | 'variables.decrypt_secret' | 'workspaces.edit_command_script' | 'workspaces.edit_deploy_to' | 'workspaces.edit_auto_invite_domain' | 'workspaces.edit_webhook' | 'workspaces.edit_copilot_config' | 'workspaces.edit_error_handler' | 'workspaces.create' | 'workspaces.update' | 'workspaces.archive' | 'workspaces.unarchive' | 'workspaces.delete';
    action_kind: 'Created' | 'Updated' | 'Delete' | 'Execute';
    resource?: string;
    parameters?: {
        [key: string]: unknown;
    };
    span?: string;
};
export type MainArgSignature = {
    type: 'Valid' | 'Invalid';
    error: string;
    star_args: boolean;
    star_kwargs?: boolean;
    args: Array<{
        name: string;
        typ: 'float' | 'int' | 'bool' | 'email' | 'unknown' | 'bytes' | 'dict' | 'datetime' | 'sql' | {
            resource: string | null;
        } | {
            str: Array<(string)> | null;
        } | {
            object: {
                name?: string;
                props?: Array<{
                    key: string;
                    typ: 'float' | 'int' | 'bool' | 'email' | 'unknown' | 'bytes' | 'dict' | 'datetime' | 'sql' | {
                        str: unknown;
                    };
                }>;
            };
        } | {
            list: 'float' | 'int' | 'bool' | 'email' | 'unknown' | 'bytes' | 'dict' | 'datetime' | 'sql' | {
                str: unknown;
            } | null;
        };
        has_default?: boolean;
        default?: unknown;
    }>;
    auto_kind: string | null;
    has_preprocessor: boolean | null;
};
export type ScriptLang = 'python3' | 'deno' | 'go' | 'bash' | 'powershell' | 'postgresql' | 'mysql' | 'bigquery' | 'snowflake' | 'mssql' | 'oracledb' | 'graphql' | 'nativets' | 'bun' | 'php' | 'rust' | 'ansible' | 'csharp' | 'nu' | 'java' | 'ruby' | 'rlang' | 'duckdb' | 'bunnative' | 'mongodb' | 'groovy' | 'kotlin' | 'dart';
/**
 * An additional module file associated with a script
 */
export type ScriptModule = {
    /**
     * The source code content of this module
     */
    content: string;
    language: ScriptLang;
    /**
     * Lock file content for this module's dependencies
     */
    lock?: string | null;
};
export type Preview = {
    /**
     * The code to run
     */
    content?: string;
    /**
     * The path to the script
     */
    path?: string;
    /**
     * The hash of the script
     */
    script_hash?: string;
    args: ScriptArgs;
    language?: ScriptLang;
    tag?: string;
    kind?: 'code' | 'identity' | 'http';
    dedicated_worker?: boolean;
    lock?: string;
    flow_path?: string;
    /**
     * Additional script modules keyed by relative file path
     */
    modules?: {
        [key: string]: ScriptModule;
    } | null;
};
export type PreviewInline = {
    /**
     * The code to run
     */
    content: string;
    args: ScriptArgs;
    language: ScriptLang;
};
export type InlineScriptArgs = {
    args?: ScriptArgs;
};
export type WorkflowTask = {
    args: ScriptArgs;
};
export type WorkflowStatusRecord = {
    [key: string]: WorkflowStatus;
};
export type WorkflowStatus = {
    scheduled_for?: string;
    started_at?: string;
    duration_ms?: number;
    name?: string;
};
export type CreateResource = {
    /**
     * The path to the resource
     */
    path: string;
    value: unknown;
    /**
     * The description of the resource
     */
    description?: string;
    /**
     * The resource_type associated with the resource
     */
    resource_type: string;
    labels?: Array<(string)>;
    ws_specific?: boolean;
};
export type EditResource = {
    /**
     * The path to the resource
     */
    path?: string;
    /**
     * The new description of the resource
     */
    description?: string;
    value?: unknown;
    /**
     * The new resource_type to be associated with the resource
     */
    resource_type?: string;
    labels?: Array<(string)>;
    ws_specific?: boolean;
};
export type Resource = {
    workspace_id?: string;
    path: string;
    description?: string;
    resource_type: string;
    value?: unknown;
    is_oauth: boolean;
    extra_perms?: {
        [key: string]: (boolean);
    };
    created_by?: string;
    edited_at?: string;
    labels?: Array<(string)>;
    ws_specific?: boolean;
};
export type ListableResource = {
    workspace_id?: string;
    path: string;
    description?: string;
    resource_type: string;
    value?: unknown;
    is_oauth: boolean;
    extra_perms?: {
        [key: string]: (boolean);
    };
    is_expired?: boolean;
    refresh_error?: string;
    is_linked: boolean;
    is_refreshed: boolean;
    account?: number;
    created_by?: string;
    edited_at?: string;
    labels?: Array<(string)>;
    ws_specific?: boolean;
};
export type ResourceType = {
    workspace_id?: string;
    name: string;
    schema?: unknown;
    description?: string;
    created_by?: string;
    edited_at?: string;
    format_extension?: string;
    is_fileset?: boolean;
};
export type EditResourceType = {
    schema?: unknown;
    description?: string;
    is_fileset?: boolean;
};
export type Schedule = {
    /**
     * The unique Orvanta path for this schedule. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`.
     */
    path: string;
    /**
     * Username of the last person who edited this schedule
     */
    edited_by: string;
    /**
     * Timestamp of the last edit
     */
    edited_at: string;
    /**
     * Cron expression with 6 fields (seconds, minutes, hours, day of month, month, day of week). Example '0 0 12 * * *' for daily at noon
     */
    schedule: string;
    /**
     * IANA timezone for the schedule (e.g., 'UTC', 'Europe/Paris', 'America/New_York')
     */
    timezone: string;
    /**
     * Whether the schedule is currently active and will trigger jobs
     */
    enabled: boolean;
    /**
     * Path to the script or flow to execute when triggered
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * True if script_path points to a BPMN flow. Read-only: such a schedule is derived from the flow's timer start event and rewritten on every deploy, so it cannot be created or edited through this API (it can be enabled/disabled). Mutually exclusive with is_flow.
     */
    is_bpmn?: boolean;
    args?: ScriptArgs | null;
    /**
     * Additional permissions for this schedule
     */
    extra_perms: {
        [key: string]: (boolean);
    };
    /**
     * Email of the user who owns this schedule, used for permissioned_as
     */
    email: string;
    /**
     * The user or group this schedule runs as (e.g., 'u/admin' or 'g/mygroup')
     */
    permissioned_as: string;
    /**
     * Last error message if the schedule failed to trigger
     */
    error?: string | null;
    /**
     * Path to a script or flow to run when the scheduled job fails
     */
    on_failure?: string | null;
    /**
     * Number of consecutive failures before the on_failure handler is triggered (default 1)
     */
    on_failure_times?: number | null;
    /**
     * If true, trigger on_failure handler only on exactly N failures, not on every failure after N
     */
    on_failure_exact?: boolean | null;
    on_failure_extra_args?: ScriptArgs | null;
    /**
     * Path to a script or flow to run when the schedule recovers after failures
     */
    on_recovery?: string | null;
    /**
     * Number of consecutive successes before the on_recovery handler is triggered (default 1)
     */
    on_recovery_times?: number | null;
    on_recovery_extra_args?: ScriptArgs | null;
    /**
     * Path to a script or flow to run after each successful execution
     */
    on_success?: string | null;
    on_success_extra_args?: ScriptArgs | null;
    /**
     * If true, the workspace-level error handler will not be triggered for this schedule's failures
     */
    ws_error_handler_muted?: boolean;
    retry?: Retry | null;
    /**
     * Short summary describing the purpose of this schedule
     */
    summary?: string | null;
    /**
     * Detailed description of what this schedule does
     */
    description?: string | null;
    /**
     * If true, skip this schedule's execution if the previous run is still in progress (prevents concurrent runs)
     */
    no_flow_overlap?: boolean;
    /**
     * Worker tag to route jobs to specific worker groups
     */
    tag?: string | null;
    /**
     * ISO 8601 datetime until which the schedule is paused. Schedule resumes automatically after this time
     */
    paused_until?: string | null;
    /**
     * Cron parser version. Use 'v2' for extended syntax with additional features
     */
    cron_version?: string | null;
    /**
     * Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean to skip (true) or run (false)
     */
    dynamic_skip?: string | null;
    labels?: Array<(string)>;
};
export type ScheduleWJobs = Schedule & {
    jobs?: Array<{
        id: string;
        success: boolean;
        duration_ms: number;
    }>;
};
export type ErrorHandler = 'custom' | 'slack' | 'teams' | 'email';
export type NewSchedule = {
    /**
     * The unique Orvanta path for this schedule. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`.
     */
    path: string;
    /**
     * Cron expression with 6 fields (seconds, minutes, hours, day of month, month, day of week). Example '0 0 12 * * *' for daily at noon
     */
    schedule: string;
    /**
     * IANA timezone for the schedule (e.g., 'UTC', 'Europe/Paris', 'America/New_York')
     */
    timezone: string;
    /**
     * Path to the script or flow to execute when triggered
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    args: ScriptArgs | null;
    /**
     * Whether the schedule is currently active and will trigger jobs
     */
    enabled?: boolean;
    /**
     * Path to a script or flow to run when the scheduled job fails
     */
    on_failure?: string | null;
    /**
     * Number of consecutive failures before the on_failure handler is triggered (default 1)
     */
    on_failure_times?: number | null;
    /**
     * If true, trigger on_failure handler only on exactly N failures, not on every failure after N
     */
    on_failure_exact?: boolean | null;
    on_failure_extra_args?: ScriptArgs | null;
    /**
     * Path to a script or flow to run when the schedule recovers after failures
     */
    on_recovery?: string | null;
    /**
     * Number of consecutive successes before the on_recovery handler is triggered (default 1)
     */
    on_recovery_times?: number | null;
    on_recovery_extra_args?: ScriptArgs | null;
    /**
     * Path to a script or flow to run after each successful execution
     */
    on_success?: string | null;
    on_success_extra_args?: ScriptArgs | null;
    /**
     * If true, the workspace-level error handler will not be triggered for this schedule's failures
     */
    ws_error_handler_muted?: boolean;
    retry?: Retry | null;
    /**
     * If true, skip this schedule's execution if the previous run is still in progress (prevents concurrent runs)
     */
    no_flow_overlap?: boolean;
    /**
     * Short summary describing the purpose of this schedule
     */
    summary?: string | null;
    /**
     * Detailed description of what this schedule does
     */
    description?: string | null;
    /**
     * Worker tag to route jobs to specific worker groups
     */
    tag?: string | null;
    /**
     * ISO 8601 datetime until which the schedule is paused. Schedule resumes automatically after this time
     */
    paused_until?: string | null;
    /**
     * Cron parser version. Use 'v2' for extended syntax with additional features
     */
    cron_version?: string | null;
    /**
     * Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean to skip (true) or run (false)
     */
    dynamic_skip?: string | null;
    /**
     * The user or group this schedule runs as. Used during deployment to preserve the original schedule owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditSchedule = {
    /**
     * Cron expression with 6 fields (seconds, minutes, hours, day of month, month, day of week). Example '0 0 12 * * *' for daily at noon
     */
    schedule: string;
    /**
     * IANA timezone for the schedule (e.g., 'UTC', 'Europe/Paris', 'America/New_York')
     */
    timezone: string;
    args: ScriptArgs | null;
    /**
     * Path to a script or flow to run when the scheduled job fails
     */
    on_failure?: string | null;
    /**
     * Number of consecutive failures before the on_failure handler is triggered (default 1)
     */
    on_failure_times?: number | null;
    /**
     * If true, trigger on_failure handler only on exactly N failures, not on every failure after N
     */
    on_failure_exact?: boolean | null;
    on_failure_extra_args?: ScriptArgs | null;
    /**
     * Path to a script or flow to run when the schedule recovers after failures
     */
    on_recovery?: string | null;
    /**
     * Number of consecutive successes before the on_recovery handler is triggered (default 1)
     */
    on_recovery_times?: number | null;
    on_recovery_extra_args?: ScriptArgs | null;
    /**
     * Path to a script or flow to run after each successful execution
     */
    on_success?: string | null;
    on_success_extra_args?: ScriptArgs | null;
    /**
     * If true, the workspace-level error handler will not be triggered for this schedule's failures
     */
    ws_error_handler_muted?: boolean;
    retry?: Retry | null;
    /**
     * If true, skip this schedule's execution if the previous run is still in progress (prevents concurrent runs)
     */
    no_flow_overlap?: boolean;
    /**
     * Short summary describing the purpose of this schedule
     */
    summary?: string | null;
    /**
     * Detailed description of what this schedule does
     */
    description?: string | null;
    /**
     * Worker tag to route jobs to specific worker groups
     */
    tag?: string | null;
    /**
     * ISO 8601 datetime until which the schedule is paused. Schedule resumes automatically after this time
     */
    paused_until?: string | null;
    /**
     * Cron parser version. Use 'v2' for extended syntax with additional features
     */
    cron_version?: string | null;
    /**
     * Path to a script that validates scheduled datetimes. Receives scheduled_for datetime and returns boolean to skip (true) or run (false)
     */
    dynamic_skip?: string | null;
    /**
     * The user or group this schedule runs as (e.g., 'u/admin' or 'g/mygroup'). Only admins and wm_deployers can set this via preserve_permissioned_as.
     */
    permissioned_as?: string | null;
    /**
     * If true and user is admin/wm_deployers, preserve the provided permissioned_as instead of using the deploying user's identity
     */
    preserve_permissioned_as?: boolean | null;
    labels?: Array<(string)>;
};
/**
 * job trigger kind (schedule, http, websocket...)
 */
export type JobTriggerKind = 'webhook' | 'default_email' | 'email' | 'schedule' | 'http' | 'websocket' | 'postgres' | 'kafka' | 'nats' | 'mqtt' | 'sqs' | 'gcp' | 'azure' | 'google' | 'github';
/**
 * job trigger mode
 */
export type TriggerMode = 'enabled' | 'disabled' | 'suspended';
export type TriggerExtraProperty = {
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when triggered
     */
    script_path: string;
    /**
     * The user or group this trigger runs as (permissioned_as)
     */
    permissioned_as: string;
    /**
     * Additional permissions for this trigger
     */
    extra_perms: {
        [key: string]: (boolean);
    };
    /**
     * The workspace this trigger belongs to
     */
    workspace_id: string;
    /**
     * Username of the last person who edited this trigger
     */
    edited_by: string;
    /**
     * Timestamp of the last edit
     */
    edited_at: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * Trigger mode (enabled/disabled)
     */
    mode: TriggerMode;
    labels?: Array<(string)>;
};
export type AuthenticationMethod = 'none' | 'orvanta' | 'api_key' | 'basic_http' | 'custom_script' | 'signature';
export type RunnableKind = 'script' | 'flow';
export type OpenapiSpecFormat = 'yaml' | 'json';
export type OpenapiHttpRouteFilters = {
    folder_regex: string;
    path_regex: string;
    route_path_regex: string;
};
export type WebhookFilters = {
    user_or_folder_regex: '*' | 'u' | 'f';
    user_or_folder_regex_value: string;
    path: string;
    runnable_kind: RunnableKind;
};
export type OpenapiV3Info = {
    title: string;
    version: string;
    description?: string;
    terms_of_service?: string;
    contact?: {
        name?: string;
        url?: string;
        email?: string;
    };
    license?: {
        name: string;
        identifier?: string;
        url?: string;
    };
};
export type GenerateOpenapiSpec = {
    info?: OpenapiV3Info;
    url?: string;
    openapi_spec_format?: OpenapiSpecFormat;
    http_route_filters?: Array<OpenapiHttpRouteFilters>;
    webhook_filters?: Array<WebhookFilters>;
};
export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch';
export type HttpRequestType = 'sync' | 'async' | 'sync_sse';
export type HttpTrigger = TriggerExtraProperty & {
    /**
     * The URL route path that will trigger this endpoint (e.g., 'api/myendpoint'). Must NOT start with a /.
     */
    route_path: string;
    /**
     * Configuration for serving static assets (s3 bucket, storage path, filename)
     */
    static_asset_config?: {
        /**
         * S3 bucket path for static assets
         */
        s3: string;
        /**
         * Storage path for static assets
         */
        storage?: string;
        /**
         * Filename for the static asset
         */
        filename?: string;
    } | null;
    /**
     * HTTP method (get, post, put, delete, patch) that triggers this endpoint
     */
    http_method: HttpMethod;
    /**
     * Path to the resource containing authentication configuration (for api_key, basic_http, custom_script, signature methods)
     */
    authentication_resource_path?: string | null;
    /**
     * Short summary describing the purpose of this trigger
     */
    summary?: string | null;
    /**
     * Detailed description of what this trigger does
     */
    description?: string | null;
    /**
     * How the request is handled - 'sync' waits for result, 'async' returns job ID immediately, 'sync_sse' streams results via Server-Sent Events
     */
    request_type: HttpRequestType;
    /**
     * How requests are authenticated - 'none' (public), 'orvanta' (Orvanta token), 'api_key', 'basic_http', 'custom_script', 'signature'
     */
    authentication_method: AuthenticationMethod;
    /**
     * If true, serves static files from S3/storage instead of running a script
     */
    is_static_website: boolean;
    /**
     * If true, the route includes the workspace ID in the path
     */
    workspaced_route: boolean;
    /**
     * If true, wraps the request body in a 'body' parameter
     */
    wrap_body: boolean;
    /**
     * If true, passes the request body as a raw string instead of parsing as JSON
     */
    raw_string: boolean;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
};
export type NewHttpTrigger = {
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when triggered
     */
    script_path: string;
    /**
     * The URL route path that will trigger this endpoint (e.g., 'api/myendpoint'). Must NOT start with a /.
     */
    route_path: string;
    /**
     * If true, the route includes the workspace ID in the path
     */
    workspaced_route?: boolean;
    /**
     * Short summary describing the purpose of this trigger
     */
    summary?: string | null;
    /**
     * Detailed description of what this trigger does
     */
    description?: string | null;
    /**
     * Configuration for serving static assets (s3 bucket, storage path, filename)
     */
    static_asset_config?: {
        /**
         * S3 bucket path for static assets
         */
        s3: string;
        /**
         * Storage path for static assets
         */
        storage?: string;
        /**
         * Filename for the static asset
         */
        filename?: string;
    } | null;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * HTTP method (get, post, put, delete, patch) that triggers this endpoint
     */
    http_method: HttpMethod;
    /**
     * Path to the resource containing authentication configuration (for api_key, basic_http, custom_script, signature methods)
     */
    authentication_resource_path?: string | null;
    /**
     * Deprecated, use request_type instead
     */
    is_async?: boolean;
    /**
     * How the request is handled - 'sync' waits for result, 'async' returns job ID immediately, 'sync_sse' streams results via Server-Sent Events
     */
    request_type?: HttpRequestType;
    /**
     * How requests are authenticated - 'none' (public), 'orvanta' (Orvanta token), 'api_key', 'basic_http', 'custom_script', 'signature'
     */
    authentication_method: AuthenticationMethod;
    /**
     * If true, serves static files from S3/storage instead of running a script
     */
    is_static_website: boolean;
    /**
     * If true, wraps the request body in a 'body' parameter
     */
    wrap_body?: boolean;
    mode?: TriggerMode;
    /**
     * If true, passes the request body as a raw string instead of parsing as JSON
     */
    raw_string?: boolean;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditHttpTrigger = {
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when triggered
     */
    script_path: string;
    /**
     * The URL route path that will trigger this endpoint (e.g., 'api/myendpoint'). Must NOT start with a /.
     */
    route_path?: string;
    /**
     * Short summary describing the purpose of this trigger
     */
    summary?: string | null;
    /**
     * Detailed description of what this trigger does
     */
    description?: string | null;
    /**
     * If true, the route includes the workspace ID in the path
     */
    workspaced_route?: boolean;
    /**
     * Configuration for serving static assets (s3 bucket, storage path, filename)
     */
    static_asset_config?: {
        /**
         * S3 bucket path for static assets
         */
        s3: string;
        /**
         * Storage path for static assets
         */
        storage?: string;
        /**
         * Filename for the static asset
         */
        filename?: string;
    } | null;
    /**
     * Path to the resource containing authentication configuration (for api_key, basic_http, custom_script, signature methods)
     */
    authentication_resource_path?: string | null;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * HTTP method (get, post, put, delete, patch) that triggers this endpoint
     */
    http_method: HttpMethod;
    /**
     * Deprecated, use request_type instead
     */
    is_async?: boolean;
    /**
     * How the request is handled - 'sync' waits for result, 'async' returns job ID immediately, 'sync_sse' streams results via Server-Sent Events
     */
    request_type?: HttpRequestType;
    /**
     * How requests are authenticated - 'none' (public), 'orvanta' (Orvanta token), 'api_key', 'basic_http', 'custom_script', 'signature'
     */
    authentication_method: AuthenticationMethod;
    /**
     * If true, serves static files from S3/storage instead of running a script
     */
    is_static_website: boolean;
    /**
     * If true, wraps the request body in a 'body' parameter
     */
    wrap_body?: boolean;
    /**
     * If true, passes the request body as a raw string instead of parsing as JSON
     */
    raw_string?: boolean;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type TriggersCount = {
    primary_schedule?: {
        schedule?: string;
    };
    schedule_count?: number;
    http_routes_count?: number;
    webhook_count?: number;
    email_count?: number;
    default_email_count?: number;
    websocket_count?: number;
    postgres_count?: number;
    kafka_count?: number;
    nats_count?: number;
    mqtt_count?: number;
    gcp_count?: number;
    azure_count?: number;
    sqs_count?: number;
    nextcloud_count?: number;
    google_count?: number;
    github_count?: number;
};
export type WebsocketHeartbeat = {
    /**
     * Interval in seconds between heartbeat messages
     */
    interval_secs: number;
    /**
     * Message to send as heartbeat. Use {{state}} as a placeholder for a value extracted from incoming messages (see state_field).
     */
    message: string;
    /**
     * Optional. Top-level JSON field to extract from incoming messages. The extracted value replaces {{state}} in the heartbeat message.
     */
    state_field?: string;
};
export type WebsocketTrigger = TriggerExtraProperty & {
    /**
     * The WebSocket URL to connect to (can be a static URL or computed by a runnable)
     */
    url: string;
    /**
     * ID of the server currently handling this trigger (internal)
     */
    server_id?: string;
    /**
     * Timestamp of last server heartbeat (internal)
     */
    last_server_ping?: string;
    /**
     * Last error message if the trigger failed
     */
    error?: string;
    /**
     * Array of key-value filters to match incoming messages (only matching messages trigger the script)
     */
    filters: Array<{
        key: string;
        value: unknown;
    }>;
    /**
     * Logic to apply when evaluating filters. 'and' requires all filters to match, 'or' requires any filter to match.
     */
    filter_logic?: 'and' | 'or';
    /**
     * Messages to send immediately after connecting (can be raw strings or computed by runnables)
     */
    initial_messages?: Array<WebsocketTriggerInitialMessage> | null;
    /**
     * Arguments to pass to the script/flow that computes the WebSocket URL
     */
    url_runnable_args?: ScriptArgs | null;
    /**
     * If true, the script can return a message to send back through the WebSocket
     */
    can_return_message: boolean;
    /**
     * If true, error results are sent back through the WebSocket
     */
    can_return_error_result: boolean;
    /**
     * Optional periodic heartbeat message configuration
     */
    heartbeat?: WebsocketHeartbeat | null;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
};
export type NewWebsocketTrigger = {
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * The WebSocket URL to connect to (can be a static URL or computed by a runnable)
     */
    url: string;
    mode?: TriggerMode;
    /**
     * Array of key-value filters to match incoming messages (only matching messages trigger the script)
     */
    filters: Array<{
        key: string;
        value: unknown;
    }>;
    /**
     * Logic to apply when evaluating filters. 'and' requires all filters to match, 'or' requires any filter to match.
     */
    filter_logic?: 'and' | 'or';
    /**
     * Messages to send immediately after connecting (can be raw strings or computed by runnables)
     */
    initial_messages?: Array<WebsocketTriggerInitialMessage> | null;
    /**
     * Arguments to pass to the script/flow that computes the WebSocket URL
     */
    url_runnable_args?: ScriptArgs | null;
    /**
     * If true, the script can return a message to send back through the WebSocket
     */
    can_return_message: boolean;
    /**
     * If true, error results are sent back through the WebSocket
     */
    can_return_error_result: boolean;
    /**
     * Optional periodic heartbeat message configuration
     */
    heartbeat?: WebsocketHeartbeat | null;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditWebsocketTrigger = {
    /**
     * The WebSocket URL to connect to (can be a static URL or computed by a runnable)
     */
    url: string;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * Array of key-value filters to match incoming messages (only matching messages trigger the script)
     */
    filters: Array<{
        key: string;
        value: unknown;
    }>;
    /**
     * Logic to apply when evaluating filters. 'and' requires all filters to match, 'or' requires any filter to match.
     */
    filter_logic?: 'and' | 'or';
    /**
     * Messages to send immediately after connecting (can be raw strings or computed by runnables)
     */
    initial_messages?: Array<WebsocketTriggerInitialMessage> | null;
    /**
     * Arguments to pass to the script/flow that computes the WebSocket URL
     */
    url_runnable_args?: ScriptArgs | null;
    /**
     * If true, the script can return a message to send back through the WebSocket
     */
    can_return_message: boolean;
    /**
     * If true, error results are sent back through the WebSocket
     */
    can_return_error_result: boolean;
    /**
     * Optional periodic heartbeat message configuration
     */
    heartbeat?: WebsocketHeartbeat | null;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type WebsocketTriggerInitialMessage = {
    raw_message: string;
} | {
    runnable_result: {
        path: string;
        args: ScriptArgs;
        is_flow: boolean;
    };
};
export type MqttQoS = 'qos0' | 'qos1' | 'qos2';
export type MqttV3Config = {
    clean_session?: boolean;
};
export type MqttV5Config = {
    clean_start?: boolean;
    topic_alias_maximum?: number;
    session_expiry_interval?: number;
};
export type MqttSubscribeTopic = {
    qos: MqttQoS;
    topic: string;
};
export type MqttClientVersion = 'v3' | 'v5';
export type MqttTrigger = TriggerExtraProperty & {
    /**
     * Path to the MQTT resource containing broker connection configuration
     */
    mqtt_resource_path: string;
    /**
     * Array of MQTT topics to subscribe to, each with topic name and QoS level
     */
    subscribe_topics: Array<MqttSubscribeTopic>;
    /**
     * MQTT v3 specific configuration (clean_session)
     */
    v3_config?: MqttV3Config | null;
    /**
     * MQTT v5 specific configuration (clean_start, topic_alias_maximum, session_expiry_interval)
     */
    v5_config?: MqttV5Config | null;
    /**
     * MQTT client ID for this connection
     */
    client_id?: string | null;
    /**
     * MQTT protocol version ('v3' or 'v5')
     */
    client_version?: MqttClientVersion | null;
    /**
     * ID of the server currently handling this trigger (internal)
     */
    server_id?: string;
    /**
     * Timestamp of last server heartbeat (internal)
     */
    last_server_ping?: string;
    /**
     * Last error message if the trigger failed
     */
    error?: string;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
};
export type NewMqttTrigger = {
    /**
     * Path to the MQTT resource containing broker connection configuration
     */
    mqtt_resource_path: string;
    /**
     * Array of MQTT topics to subscribe to, each with topic name and QoS level
     */
    subscribe_topics: Array<MqttSubscribeTopic>;
    /**
     * MQTT client ID for this connection
     */
    client_id?: string | null;
    /**
     * MQTT v3 specific configuration (clean_session)
     */
    v3_config?: MqttV3Config | null;
    /**
     * MQTT v5 specific configuration (clean_start, topic_alias_maximum, session_expiry_interval)
     */
    v5_config?: MqttV5Config | null;
    /**
     * MQTT protocol version ('v3' or 'v5')
     */
    client_version?: MqttClientVersion | null;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    mode?: TriggerMode;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditMqttTrigger = {
    /**
     * Path to the MQTT resource containing broker connection configuration
     */
    mqtt_resource_path: string;
    /**
     * Array of MQTT topics to subscribe to, each with topic name and QoS level
     */
    subscribe_topics: Array<MqttSubscribeTopic>;
    /**
     * MQTT client ID for this connection
     */
    client_id?: string | null;
    /**
     * MQTT v3 specific configuration (clean_session)
     */
    v3_config?: MqttV3Config | null;
    /**
     * MQTT v5 specific configuration (clean_start, topic_alias_maximum, session_expiry_interval)
     */
    v5_config?: MqttV5Config | null;
    /**
     * MQTT protocol version ('v3' or 'v5')
     */
    client_version?: MqttClientVersion | null;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    mode?: TriggerMode;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
/**
 * Delivery mode for messages. 'push' for HTTP push delivery where messages are sent to a webhook endpoint, 'pull' for polling where the trigger actively fetches messages.
 */
export type DeliveryType = 'push' | 'pull';
/**
 * Configuration for push delivery mode.
 */
export type PushConfig = {
    /**
     * The audience claim for OIDC tokens used in push authentication.
     */
    audience?: string;
    /**
     * If true, push messages will include OIDC authentication tokens.
     */
    authenticate: boolean;
};
/**
 * A Google Cloud Pub/Sub trigger that executes a script or flow when messages are received.
 */
export type GcpTrigger = TriggerExtraProperty & {
    /**
     * Path to the GCP resource containing service account credentials for authentication.
     */
    gcp_resource_path: string;
    /**
     * Google Cloud Pub/Sub topic ID to subscribe to.
     */
    topic_id: string;
    /**
     * Google Cloud Pub/Sub subscription ID.
     */
    subscription_id: string;
    /**
     * ID of the server currently handling this trigger (internal use).
     */
    server_id?: string;
    delivery_type: DeliveryType;
    delivery_config?: PushConfig | null;
    subscription_mode: SubscriptionMode;
    /**
     * Timestamp of last server heartbeat (internal use).
     */
    last_server_ping?: string;
    /**
     * Last error message if the trigger failed.
     */
    error?: string;
    /**
     * Path to a script or flow to run when the triggered job fails.
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler.
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions.
     */
    retry?: Retry;
};
/**
 * The mode of subscription. 'existing' means using an existing GCP subscription, while 'create_update' involves creating or updating a new subscription.
 */
export type SubscriptionMode = 'existing' | 'create_update';
/**
 * Data for creating or updating a Google Cloud Pub/Sub trigger.
 */
export type GcpTriggerData = {
    /**
     * Path to the GCP resource containing service account credentials for authentication.
     */
    gcp_resource_path: string;
    subscription_mode: SubscriptionMode;
    /**
     * Google Cloud Pub/Sub topic ID to subscribe to.
     */
    topic_id: string;
    /**
     * Google Cloud Pub/Sub subscription ID.
     */
    subscription_id?: string;
    /**
     * Base URL for push delivery endpoint.
     */
    base_endpoint?: string;
    delivery_type?: DeliveryType;
    delivery_config?: PushConfig | null;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received.
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script.
     */
    is_flow: boolean;
    mode?: TriggerMode;
    /**
     * If true, automatically acknowledge messages after processing.
     */
    auto_acknowledge_msg?: boolean;
    /**
     * Time in seconds within which the message must be acknowledged. If not provided, defaults to the subscription's acknowledgment deadline (600 seconds).
     */
    ack_deadline?: number;
    /**
     * Path to a script or flow to run when the triggered job fails.
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler.
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions.
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type GetAllTopicSubscription = {
    topic_id: string;
};
export type DeleteGcpSubscription = {
    subscription_id: string;
};
/**
 * Azure Event Grid trigger mode.
 */
export type AzureMode = 'basic_push' | 'namespace_push' | 'namespace_pull';
/**
 * An ARM resource the service principal can see.
 */
export type AzureArmResource = {
    id: string;
    name: string;
    location?: string;
    type: string;
};
export type AzureDeleteSubscription = {
    azure_mode: AzureMode;
    scope_resource_id: string;
    topic_name?: string | null;
    subscription_name: string;
};
/**
 * An Azure Event Grid trigger that executes a script or flow when events arrive.
 */
export type AzureTrigger = TriggerExtraProperty & {
    azure_resource_path: string;
    azure_mode: AzureMode;
    /**
     * ARM resource ID of the topic (basic) or namespace (namespace modes).
     */
    scope_resource_id: string;
    /**
     * Topic name within the namespace (namespace modes only).
     */
    topic_name?: string | null;
    subscription_name: string;
    event_type_filters?: Array<(string)> | null;
    server_id?: string;
    last_server_ping?: string;
    error?: string;
    error_handler_path?: string;
    error_handler_args?: ScriptArgs;
    retry?: Retry;
};
/**
 * Data for creating or updating an Azure Event Grid trigger.
 */
export type AzureTriggerData = {
    azure_resource_path: string;
    azure_mode: AzureMode;
    scope_resource_id: string;
    topic_name?: string | null;
    subscription_name: string;
    /**
     * Base URL for push delivery endpoints (push modes only).
     */
    base_endpoint?: string;
    event_type_filters?: Array<(string)>;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    script_path: string;
    is_flow: boolean;
    mode?: TriggerMode;
    error_handler_path?: string;
    error_handler_args?: ScriptArgs;
    retry?: Retry;
    permissioned_as?: string;
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type TestAzureConnection = {
    azure_resource_path: string;
};
export type AzureListTopics = {
    scope_resource_id: string;
};
export type AzureListSubscriptions = {
    scope_resource_id: string;
    topic_name: string;
};
export type AwsAuthResourceType = 'oidc' | 'credentials';
export type SqsTrigger = TriggerExtraProperty & {
    /**
     * The full URL of the AWS SQS queue to poll for messages
     */
    queue_url: string;
    /**
     * Authentication type - 'credentials' for access key/secret, 'oidc' for OpenID Connect
     */
    aws_auth_resource_type: AwsAuthResourceType;
    /**
     * Path to the AWS resource containing credentials or OIDC configuration
     */
    aws_resource_path: string;
    /**
     * Array of SQS message attribute names to include with each message
     */
    message_attributes?: Array<(string)> | null;
    /**
     * ID of the server currently handling this trigger (internal)
     */
    server_id?: string;
    /**
     * Timestamp of last server heartbeat (internal)
     */
    last_server_ping?: string;
    /**
     * Last error message if the trigger failed
     */
    error?: string;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
};
export type LoggedWizardStatus = 'OK' | 'SKIP' | 'FAIL';
export type CustomInstanceDbLogs = {
    super_admin?: LoggedWizardStatus;
    database_credentials?: LoggedWizardStatus;
    valid_dbname?: LoggedWizardStatus;
    created_database?: LoggedWizardStatus;
    db_connect?: LoggedWizardStatus;
    grant_permissions?: LoggedWizardStatus;
};
export type CustomInstanceDbTag = 'ducklake' | 'datatable';
export type CustomInstanceDb = {
    logs: CustomInstanceDbLogs;
    /**
     * Whether the operation completed successfully
     */
    success: boolean;
    /**
     * Error message if the operation failed
     */
    error?: string | null;
    tag?: CustomInstanceDbTag;
};
export type NewSqsTrigger = {
    /**
     * The full URL of the AWS SQS queue to poll for messages
     */
    queue_url: string;
    /**
     * Authentication type - 'credentials' for access key/secret, 'oidc' for OpenID Connect
     */
    aws_auth_resource_type: AwsAuthResourceType;
    /**
     * Path to the AWS resource containing credentials or OIDC configuration
     */
    aws_resource_path: string;
    /**
     * Array of SQS message attribute names to include with each message
     */
    message_attributes?: Array<(string)> | null;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    mode?: TriggerMode;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditSqsTrigger = {
    /**
     * The full URL of the AWS SQS queue to poll for messages
     */
    queue_url: string;
    /**
     * Authentication type - 'credentials' for access key/secret, 'oidc' for OpenID Connect
     */
    aws_auth_resource_type: AwsAuthResourceType;
    /**
     * Path to the AWS resource containing credentials or OIDC configuration
     */
    aws_resource_path: string;
    /**
     * Array of SQS message attribute names to include with each message
     */
    message_attributes?: Array<(string)> | null;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    mode?: TriggerMode;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type Slot = {
    name?: string;
};
export type SlotList = {
    slot_name?: string;
    active?: boolean;
};
export type PublicationData = {
    table_to_track?: Array<Relations>;
    transaction_to_track: Array<(string)>;
};
export type TableToTrack = Array<{
    table_name: string;
    columns_name?: Array<(string)>;
    where_clause?: string;
}>;
export type Relations = {
    schema_name: string;
    table_to_track: TableToTrack;
};
export type Language = 'Typescript';
export type TemplateScript = {
    postgres_resource_path: string;
    relations: Array<Relations>;
    language: Language;
};
export type PostgresTrigger = TriggerExtraProperty & {
    /**
     * Path to the PostgreSQL resource containing connection configuration
     */
    postgres_resource_path: string;
    /**
     * Name of the PostgreSQL publication to subscribe to for change data capture
     */
    publication_name: string;
    /**
     * ID of the server currently handling this trigger (internal)
     */
    server_id?: string;
    /**
     * Name of the PostgreSQL logical replication slot to use
     */
    replication_slot_name: string;
    /**
     * Last error message if the trigger failed
     */
    error?: string;
    /**
     * Timestamp of last server heartbeat (internal)
     */
    last_server_ping?: string;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
};
export type NewPostgresTrigger = {
    /**
     * Name of the PostgreSQL logical replication slot to use
     */
    replication_slot_name?: string;
    /**
     * Name of the PostgreSQL publication to subscribe to for change data capture
     */
    publication_name?: string;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when database changes are detected
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    mode?: TriggerMode;
    /**
     * Path to the PostgreSQL resource containing connection configuration
     */
    postgres_resource_path: string;
    /**
     * Configuration for creating/managing the publication (tables, operations)
     */
    publication?: PublicationData;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditPostgresTrigger = {
    /**
     * Name of the PostgreSQL logical replication slot to use
     */
    replication_slot_name: string;
    /**
     * Name of the PostgreSQL publication to subscribe to for change data capture
     */
    publication_name: string;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when database changes are detected
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    mode?: TriggerMode;
    /**
     * Path to the PostgreSQL resource containing connection configuration
     */
    postgres_resource_path: string;
    /**
     * Configuration for creating/managing the publication (tables, operations)
     */
    publication?: PublicationData;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type KafkaTrigger = TriggerExtraProperty & {
    /**
     * Path to the Kafka resource containing connection configuration
     */
    kafka_resource_path: string;
    /**
     * Kafka consumer group ID for this trigger
     */
    group_id: string;
    /**
     * Array of Kafka topic names to subscribe to
     */
    topics: Array<(string)>;
    filters: Array<{
        key: string;
        value: unknown;
    }>;
    /**
     * Logic to apply when evaluating filters. 'and' requires all filters to match, 'or' requires any filter to match.
     */
    filter_logic?: 'and' | 'or';
    /**
     * Initial offset behavior when consumer group has no committed offset. 'latest' starts from new messages only, 'earliest' starts from the beginning.
     */
    auto_offset_reset?: 'latest' | 'earliest';
    /**
     * When true (default), offsets are committed automatically after receiving each message. When false, you must manually commit offsets using the commit_offsets endpoint.
     */
    auto_commit?: boolean;
    /**
     * ID of the server currently handling this trigger (internal)
     */
    server_id?: string;
    /**
     * Timestamp of last server heartbeat (internal)
     */
    last_server_ping?: string;
    /**
     * Last error message if the trigger failed
     */
    error?: string;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
};
export type NewKafkaTrigger = {
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * Path to the Kafka resource containing connection configuration
     */
    kafka_resource_path: string;
    /**
     * Kafka consumer group ID for this trigger
     */
    group_id: string;
    /**
     * Array of Kafka topic names to subscribe to
     */
    topics: Array<(string)>;
    filters: Array<{
        key: string;
        value: unknown;
    }>;
    /**
     * Logic to apply when evaluating filters. 'and' requires all filters to match, 'or' requires any filter to match.
     */
    filter_logic?: 'and' | 'or';
    /**
     * Initial offset behavior when consumer group has no committed offset.
     */
    auto_offset_reset?: 'latest' | 'earliest';
    /**
     * When true (default), offsets are committed automatically after receiving each message. When false, you must manually commit offsets using the commit_offsets endpoint.
     */
    auto_commit?: boolean;
    mode?: TriggerMode;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditKafkaTrigger = {
    /**
     * Path to the Kafka resource containing connection configuration
     */
    kafka_resource_path: string;
    /**
     * Kafka consumer group ID for this trigger
     */
    group_id: string;
    /**
     * Array of Kafka topic names to subscribe to
     */
    topics: Array<(string)>;
    filters: Array<{
        key: string;
        value: unknown;
    }>;
    /**
     * Logic to apply when evaluating filters. 'and' requires all filters to match, 'or' requires any filter to match.
     */
    filter_logic?: 'and' | 'or';
    /**
     * Initial offset behavior when consumer group has no committed offset.
     */
    auto_offset_reset?: 'latest' | 'earliest';
    /**
     * When true (default), offsets are committed automatically after receiving each message. When false, you must manually commit offsets using the commit_offsets endpoint.
     */
    auto_commit?: boolean;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type NatsTrigger = TriggerExtraProperty & {
    /**
     * Path to the NATS resource containing connection configuration
     */
    nats_resource_path: string;
    /**
     * If true, uses NATS JetStream for durable message delivery
     */
    use_jetstream: boolean;
    /**
     * JetStream stream name (required when use_jetstream is true)
     */
    stream_name?: string | null;
    /**
     * JetStream consumer name (required when use_jetstream is true)
     */
    consumer_name?: string | null;
    /**
     * Array of NATS subjects to subscribe to
     */
    subjects: Array<(string)>;
    /**
     * ID of the server currently handling this trigger (internal)
     */
    server_id?: string;
    /**
     * Timestamp of last server heartbeat (internal)
     */
    last_server_ping?: string;
    /**
     * Last error message if the trigger failed
     */
    error?: string;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
};
export type NewNatsTrigger = {
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * Path to the NATS resource containing connection configuration
     */
    nats_resource_path: string;
    /**
     * If true, uses NATS JetStream for durable message delivery
     */
    use_jetstream: boolean;
    /**
     * JetStream stream name (required when use_jetstream is true)
     */
    stream_name?: string | null;
    /**
     * JetStream consumer name (required when use_jetstream is true)
     */
    consumer_name?: string | null;
    /**
     * Array of NATS subjects to subscribe to
     */
    subjects: Array<(string)>;
    mode?: TriggerMode;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditNatsTrigger = {
    /**
     * Path to the NATS resource containing connection configuration
     */
    nats_resource_path: string;
    /**
     * If true, uses NATS JetStream for durable message delivery
     */
    use_jetstream: boolean;
    /**
     * JetStream stream name (required when use_jetstream is true)
     */
    stream_name?: string | null;
    /**
     * JetStream consumer name (required when use_jetstream is true)
     */
    consumer_name?: string | null;
    /**
     * Array of NATS subjects to subscribe to
     */
    subjects: Array<(string)>;
    /**
     * The unique Orvanta path for this trigger. Must be of the form `u/<user>/<path>` or `f/<folder>/<path>`. This is the trigger object path, not the HTTP route path.
     */
    path: string;
    /**
     * Path to the script or flow to execute when a message is received
     */
    script_path: string;
    /**
     * True if script_path points to a flow, false if it points to a script
     */
    is_flow: boolean;
    /**
     * Path to a script or flow to run when the triggered job fails
     */
    error_handler_path?: string;
    /**
     * Arguments to pass to the error handler
     */
    error_handler_args?: ScriptArgs;
    /**
     * Retry configuration for failed executions
     */
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EmailTrigger = TriggerExtraProperty & {
    local_part: string;
    workspaced_local_part?: boolean;
    error_handler_path?: string;
    error_handler_args?: ScriptArgs;
    retry?: Retry;
};
export type NewEmailTrigger = {
    path: string;
    script_path: string;
    local_part: string;
    workspaced_local_part?: boolean;
    is_flow: boolean;
    error_handler_path?: string;
    error_handler_args?: ScriptArgs;
    retry?: Retry;
    mode?: TriggerMode;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type EditEmailTrigger = {
    path: string;
    script_path: string;
    local_part?: string;
    workspaced_local_part?: boolean;
    is_flow: boolean;
    error_handler_path?: string;
    error_handler_args?: ScriptArgs;
    retry?: Retry;
    /**
     * The user or group this trigger runs as. Used during deployment to preserve the original trigger owner.
     */
    permissioned_as?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original permissioned_as value instead of overwriting it.
     */
    preserve_permissioned_as?: boolean;
    labels?: Array<(string)>;
};
export type Group = {
    name: string;
    summary?: string;
    members?: Array<(string)>;
    extra_perms?: {
        [key: string]: (boolean);
    };
};
export type InstanceGroup = {
    name: string;
    summary?: string;
    emails?: Array<(string)>;
    instance_role?: 'superadmin' | 'devops' | null;
};
export type InstanceGroupWithWorkspaces = {
    name: string;
    summary?: string;
    emails?: Array<(string)>;
    instance_role?: 'superadmin' | 'devops' | null;
    workspaces?: Array<WorkspaceInfo>;
};
export type WorkspaceInfo = {
    workspace_id?: string;
    workspace_name?: string;
    role?: string;
};
export type Folder = {
    name: string;
    owners: Array<(string)>;
    extra_perms: {
        [key: string]: (boolean);
    };
    summary?: string;
    created_by?: string;
    edited_at?: string;
    default_permissioned_as?: FolderDefaultPermissionedAs;
};
/**
 * Ordered list of rules applied at create-time when admins or `wm_deployers` members deploy items in this folder. The first rule whose `path_glob` matches the item path (relative to the folder root) wins, and its `permissioned_as` is used as the default.
 *
 */
export type FolderDefaultPermissionedAs = Array<{
    /**
     * Glob pattern evaluated against the item path *relative* to the folder root (e.g. "jobs**" matches every item whose full path is `f/<folder>/jobs/...`). Supports `*`, `**`, `?`, `[abc]`, `{a,b}`.
     *
     */
    path_glob: string;
    /**
     * Target identity the matched item should be permissioned as. Must be `u/<username>`, `g/<groupname>`, or an email that exists in this workspace.
     *
     */
    permissioned_as: string;
}>;
export type WorkerPing = {
    worker: string;
    worker_instance: string;
    last_ping?: number;
    started_at: string;
    ip: string;
    jobs_executed: number;
    custom_tags?: Array<(string)>;
    worker_group: string;
    wm_version: string;
    last_job_id?: string;
    last_job_workspace_id?: string;
    occupancy_rate?: number;
    occupancy_rate_15s?: number;
    occupancy_rate_5m?: number;
    occupancy_rate_30m?: number;
    memory?: number;
    vcpus?: number;
    memory_usage?: number;
    wm_memory_usage?: number;
    job_isolation?: string;
    native_mode?: boolean;
};
export type UserWorkspaceList = {
    email: string;
    workspaces: Array<{
        id: string;
        name: string;
        username: string;
        color: string;
        operator_settings?: OperatorSettings;
        parent_workspace_id?: string | null;
        created_by?: string | null;
        disabled: boolean;
    }>;
};
export type CreateWorkspace = {
    id: string;
    name: string;
    username?: string;
    color?: string;
};
export type CreateWorkspaceFork = {
    id: string;
    name: string;
    color?: string;
    forked_datatables?: Array<{
        /**
         * Datatable name
         */
        name: string;
        /**
         * New database name for the fork
         */
        new_dbname: string;
    }>;
};
export type Workspace = {
    id: string;
    name: string;
    owner: string;
    domain?: string;
    color?: string;
    parent_workspace_id?: string | null;
};
export type DependencyMap = {
    workspace_id?: string | null;
    importer_path?: string | null;
    importer_kind?: string | null;
    imported_path?: string | null;
    importer_node_id?: string | null;
};
export type DependencyDependent = {
    importer_path: string;
    importer_kind: 'script' | 'flow' | 'app';
    importer_node_ids?: Array<(string)> | null;
};
export type DependentsAmount = {
    imported_path: string;
    count: number;
};
export type WorkspaceInvite = {
    workspace_id: string;
    email: string;
    is_admin: boolean;
    operator: boolean;
    parent_workspace_id?: string | null;
};
export type GlobalUserInfo = {
    email: string;
    login_type: 'password' | 'github';
    super_admin: boolean;
    devops?: boolean;
    verified: boolean;
    name?: string;
    company?: string;
    username?: string;
    operator_only?: boolean;
    first_time_user: boolean;
    role_source: 'manual' | 'instance_group';
    disabled: boolean;
};
export type Flow = OpenFlow & FlowMetadata & {
    lock_error_logs?: string;
    version_id?: number;
};
export type ExtraPerms = {
    [key: string]: (boolean);
};
export type FlowMetadata = {
    workspace_id?: string;
    path: string;
    edited_by: string;
    edited_at: string;
    archived: boolean;
    extra_perms: ExtraPerms;
    starred?: boolean;
    draft_only?: boolean;
    tag?: string;
    ws_error_handler_muted?: boolean;
    priority?: number;
    dedicated_worker?: boolean;
    timeout?: number;
    visible_to_runner_only?: boolean;
    on_behalf_of_email?: string;
    labels?: Array<(string)>;
};
export type OpenFlowWPath = OpenFlow & {
    path: string;
    tag?: string;
    ws_error_handler_muted?: boolean;
    priority?: number;
    dedicated_worker?: boolean;
    timeout?: number;
    visible_to_runner_only?: boolean;
    on_behalf_of_email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of_email value instead of overwriting it.
     */
    preserve_on_behalf_of?: boolean;
    labels?: Array<(string)>;
};
export type FlowPreview = {
    value: FlowValue;
    path?: string;
    args: ScriptArgs;
    tag?: string;
    restarted_from?: RestartedFrom;
};
export type RestartedFrom = {
    flow_job_id?: string;
    step_id?: string;
    /**
     * 0-based iteration index for ForLoop / branch index for BranchAll. Iterations 0..n-1 are preserved; iteration n is restarted.
     */
    branch_or_iteration_n?: number;
    flow_version?: number;
    /**
     * For BranchOne nested restart — the branch that was originally chosen, used to lock branch evaluation.
     */
    branch_chosen?: {
        type?: 'default' | 'branch';
        branch?: number;
    };
    /**
     * When set, the worker spawns the child for `step_id` as a `RestartedFlow` against `nested.flow_job_id` instead of fresh-launching it.
     */
    nested?: RestartedFrom;
};
export type Policy = {
    triggerables?: {
        [key: string]: {
            [key: string]: unknown;
        };
    };
    triggerables_v2?: {
        [key: string]: {
            [key: string]: unknown;
        };
    };
    s3_inputs?: Array<{
        [key: string]: unknown;
    }>;
    allowed_s3_keys?: Array<{
        s3_path?: string;
        resource?: string;
    }>;
    execution_mode?: 'viewer' | 'publisher' | 'anonymous';
    on_behalf_of?: string;
    on_behalf_of_email?: string;
};
export type ListableApp = {
    id: number;
    workspace_id: string;
    path: string;
    summary: string;
    version: number;
    extra_perms: {
        [key: string]: (boolean);
    };
    starred?: boolean;
    edited_at: string;
    execution_mode: 'viewer' | 'publisher' | 'anonymous';
    raw_app?: boolean;
    labels?: Array<(string)>;
};
export type ScopeDefinition = {
    value: string;
    label: string;
    description?: string | null;
    requires_resource_path: boolean;
};
export type ScopeDomain = {
    name: string;
    description?: string | null;
    scopes: Array<ScopeDefinition>;
};
export type ListableRawApp = {
    workspace_id: string;
    path: string;
    summary: string;
    extra_perms: {
        [key: string]: (boolean);
    };
    starred?: boolean;
    version: number;
    edited_at: string;
    labels?: Array<(string)>;
};
export type AppWithLastVersion = {
    id: number;
    workspace_id: string;
    path: string;
    summary: string;
    versions: Array<(number)>;
    created_by: string;
    created_at: string;
    value: unknown;
    policy: Policy;
    execution_mode: 'viewer' | 'publisher' | 'anonymous';
    extra_perms: {
        [key: string]: (boolean);
    };
    custom_path?: string;
    raw_app: boolean;
    bundle_secret?: string;
    labels?: Array<(string)>;
};
export type AppWithLastVersionWDraft = AppWithLastVersion & {
    draft_only?: boolean;
    draft?: unknown;
};
export type AppHistory = {
    version: number;
    deployment_msg?: string;
};
export type FlowVersion = {
    id: number;
    created_at: string;
    deployment_msg?: string;
};
export type BpmnFlow = {
    workspace_id: string;
    path: string;
    summary: string;
    description: string;
    bpmn_xml: string;
    /**
     * JSON Schema of the process's start variables, derived from the diagram at deploy time unless the deploying client supplied its own. Renders the run form. Absent for flows deployed before start-variable schemas existed.
     */
    schema?: {
        [key: string]: unknown;
    };
    draft_only?: boolean;
    labels?: Array<(string)>;
    archived: boolean;
    edited_by: string;
    edited_at: string;
    extra_perms: ExtraPerms;
    version_id?: number;
};
export type ListableBpmnFlow = {
    workspace_id: string;
    path: string;
    summary: string;
    description?: string;
    edited_by?: string;
    edited_at?: string;
    archived: boolean;
    extra_perms: ExtraPerms;
    starred?: boolean;
    has_draft: boolean;
    draft_only?: boolean;
    labels?: Array<(string)>;
};
/**
 * One projected element (or the process itself) from a BPMN document's
 * search projection (#659) — id/name plus, on a scriptTask/serviceTask
 * or businessRuleTask, its script or decision binding.
 *
 */
export type SearchBpmnNode = {
    id: string;
    name?: string;
    script_path?: string;
    script_hash?: string;
    decision_ref?: string;
};
export type BpmnFlowWithDraft = {
    path: string;
    summary: string;
    description: string;
    bpmn_xml: string;
    /**
     * JSON Schema of the deployed version's start variables (see `BpmnFlow.schema`). Always the deployed version's — a draft carries no schema of its own.
     */
    schema?: {
        [key: string]: unknown;
    };
    extra_perms: ExtraPerms;
    draft_only?: boolean;
    draft?: {
        [key: string]: unknown;
    };
    labels?: Array<(string)>;
};
export type NewBpmnFlow = {
    path: string;
    summary: string;
    description?: string;
    bpmn_xml: string;
    /**
     * JSON Schema of the process's start variables (the `flow_input` accepted by `POST /bpmn/run/p/{path}`). Optional: when omitted, it is derived server-side from the deployed diagram — declared start form properties plus variables the process reads but never sets. Supply one only to override that derivation.
     */
    schema?: {
        [key: string]: unknown;
    };
    draft_only?: boolean;
    labels?: Array<(string)>;
};
/**
 * One problem found by deploy-time BPMN validation (`backend/orvanta-bpmn/src/validate.rs`). Warnings and errors share this shape and are told apart by `severity`.
 */
export type BpmnValidationIssue = {
    /**
     * The rule that fired, e.g. `MissingScriptBinding`, `IncompleteConditionCoverage`. Stable — branch on this, not on `message`.
     */
    code: string;
    /**
     * `error` blocks the deploy (the request is a 400). `warning` does not: the deploy succeeded and the warning is advisory.
     */
    severity: 'error' | 'warning';
    /**
     * A sentence for a human, naming the offending id(s).
     */
    message: string;
    /**
     * The elements this problem is *about* — what an editor should mark on the canvas. Empty when the problem names nothing on the canvas (an unnamed unrecognized element, a whole-scope rule on the root process). Never the id of a *referenced* element that is missing: marking that would flag an innocent shape.
     */
    element_ids: Array<(string)>;
};
/**
 * The result of a successful BPMN deploy. `warnings` is empty on a clean deploy; a non-empty list does **not** mean the deploy failed.
 */
export type BpmnDeployResult = {
    path: string;
    warnings: Array<BpmnValidationIssue>;
};
/**
 * Result of seeding the Orvanta Quick Starts Polyglot BPMN process (#1090).
 */
export type PolyglotBpmnSeedResult = {
    /**
     * Workspace path the process was (or already was) deployed at.
     */
    bpmn_path: string;
    /**
     * Workspace paths of the five seeded scripts, in template order.
     */
    script_paths: Array<(string)>;
    /**
     * `true` when the process already existed and this call created nothing -- the idempotent short-circuit, not an error.
     */
    already_seeded: boolean;
};
/**
 * A rejected BPMN deploy. `issues` carries every problem found, not just the first, so one round trip is enough to fix them all; warnings found alongside the errors are included with `severity: warning`.
 */
export type BpmnValidationProblem = {
    /**
     * A readable summary, for a client that reads one field.
     */
    error: string;
    /**
     * Empty for a parse failure — the document never became a model, so there is no element to anchor to.
     */
    issues: Array<BpmnValidationIssue>;
};
/**
 * Which BPMN dialect attribute the delegate key was read from. Part of the lookup key, not decoration: in Flowable, `flowable:class="foo"` and `flowable:delegateExpression="${foo}"` are different constructs, and letting a binding for one satisfy a reference to the other would be a silent semantic mix.
 */
export type DelegateKeyKind = 'class' | 'bean' | 'expression';
/**
 * `script` runs the bound script as an ordinary child job. `noop` completes the element immediately, writes `results.<element_id> = null` and records the skip in the job trace — it grants nothing, which makes it the safest row kind, and its `reason` is mandatory. `fail` is a deploy error naming the element: "we looked and decided not yet", a different state from unbound ("nobody looked"), and the difference is carried entirely by `reason`.
 */
export type DelegateBindingKind = 'script' | 'noop' | 'fail';
/**
 * A delegate key mapped to an Orvanta script. `delegate_key` is opaque and compared byte-for-byte; it is never interpreted as a class name, a path or a URL. `path` — not the key — is the ACL anchor that RLS and ownership checks are evaluated against.
 */
export type BpmnDelegateBinding = {
    path: string;
    key_kind: DelegateKeyKind;
    delegate_key: string;
    kind: DelegateBindingKind;
    /**
     * Present iff `kind` is `script`.
     */
    script_path?: string;
    /**
     * Present iff `kind` is `noop` or `fail`; required there.
     */
    reason?: string;
    /**
     * #635 `ParamMapping` — how the result lands in process variables.
     */
    outputs?: unknown;
    /**
     * `mapException` as a catch-all.
     */
    exception_map?: unknown;
    summary: string;
    extra_perms: {
        [key: string]: (boolean);
    };
    edited_by: string;
    edited_at: string;
};
export type ListedBpmnDelegateBinding = {
    path: string;
    key_kind: DelegateKeyKind;
    delegate_key: string;
    kind: DelegateBindingKind;
    script_path?: string;
    reason?: string;
    summary: string;
    edited_by: string;
    edited_at: string;
};
/**
 * Create/update payload. On update `delegate_key` must equal the stored value — the key is not editable, because deployed models reference it by name and repointing it in place would rebind every one of them.
 */
export type NewBpmnDelegateBinding = {
    path: string;
    key_kind: DelegateKeyKind;
    delegate_key: string;
    kind: DelegateBindingKind;
    script_path?: string;
    reason?: string;
    outputs?: unknown;
    exception_map?: unknown;
    summary?: string;
};
/**
 * One place a delegate key is referenced from.
 */
export type DelegateOccurrence = {
    /**
     * The `bpmn_flow.path` the reference was read from.
     */
    flow_path: string;
    /**
     * The `serviceTask` element id -- what an editor should highlight.
     */
    element_id: string;
    /**
     * True when the reference comes from a `draft_only` definition (an imported-but-not-yet-deployable estate) rather than a deployed one.
     */
    draft_only: boolean;
};
/**
 * One row of the unbound-delegate checklist -- a distinct `(key_kind, key)` with no binding row yet, and every place it is referenced from.
 */
export type UnboundDelegateChecklistEntry = {
    key_kind: DelegateKeyKind;
    key: string;
    occurrences: Array<DelegateOccurrence>;
};
/**
 * The outcome of a whole-file import: every binding path that was newly created vs. an existing one that was updated in place.
 */
export type ImportDelegateBindingsResult = {
    created: Array<(string)>;
    updated: Array<(string)>;
};
export type BpmnFlowVersion = {
    id: number;
    created_at: string;
};
/**
 * initial process variables, seeded into the root scope
 */
export type StartBpmnInstance = {
    /**
     * Start variables for this instance, addressed by the process as `flow_input.<name>`. Shape them after the flow's `schema`.
     */
    flow_input?: {
        [key: string]: unknown;
    };
};
/**
 * An inline, possibly-undeployed BPMN diagram plus initial process variables (#710 stage 3) -- the request body for `POST /bpmn/run/preview`.
 */
export type PreviewBpmnInstance = {
    /**
     * the BPMN 2.0 XML as currently open in the editor
     */
    bpmn_xml: string;
    /**
     * Optional: only for scope-checking and job attribution (audit log, job list). Never resolved to a deployed `bpmn_flow` row.
     */
    path?: string | null;
    /**
     * Start variables for this run, addressed by the process as `flow_input.<name>`.
     */
    flow_input?: {
        [key: string]: unknown;
    };
};
export type CancelBpmnInstance = {
    reason?: string | null;
};
/**
 * one row of the instance list -- cheap columns only, no tokens/activities/variables (see BpmnInstanceDetail)
 */
export type BpmnInstanceSummary = {
    id: string;
    workspace_id: string;
    bpmn_flow_path?: string | null;
    bpmn_version?: number | null;
    created_at: string;
    created_by: string;
    started_at?: string | null;
    completed_at?: string | null;
    job_status?: string | null;
    canceled_by?: string | null;
    /**
     * process_status.lifecycle's tagged type: running / completed / incident. NULL if the engine has not picked the instance up yet.
     */
    lifecycle?: 'running' | 'completed' | 'incident' | null;
};
/**
 * one option of an enumerated form field (`<flowable:value>` / `<camunda:value>`)
 */
export type BpmnUserTaskFormFieldValue = {
    id: string;
    name?: string | null;
};
/**
 * One declared field of a user task's form, compiled from
 * `<flowable:formProperty>` or `<camunda:formField>` (#705). This is the
 * same model the completion payload is validated against (#833), so a
 * client that renders exactly these fields and nothing else cannot
 * submit something the server will reject for being unrecognised.
 *
 */
export type BpmnUserTaskFormField = {
    /**
     * the field's name in the process's variable space
     */
    id: string;
    label?: string | null;
    /**
     * carried verbatim from the document: string, long, enum, date, boolean, ...
     */
    field_type?: string | null;
    date_pattern?: string | null;
    /**
     * the process variable this field reads/writes when it differs from id
     */
    variable?: string | null;
    /**
     * the declared default, as authored (a literal or an expression)
     */
    default?: unknown;
    required?: boolean;
    readable: boolean;
    writable: boolean;
    values?: Array<BpmnUserTaskFormFieldValue>;
    origin: 'dialect_form_property' | 'dialect_form_field';
};
/**
 * One `<userTask>` parked awaiting a human, with the process context
 * needed to act on it (#1104). Every field is read off the persisted
 * process status or the compiled user-task model -- there is no claim
 * ledger and no `claimed_by`, because the engine records no such thing.
 *
 */
export type PendingUserTask = {
    /**
     * the process instance -- the `id` path segment of the completion operation
     */
    instance_id: string;
    workspace_id: string;
    /**
     * the `<userTask>` element id -- the `user_task_id` path segment of the completion operation
     */
    element_id: string;
    /**
     * `<userTask name="...">`, the label an author wrote for a human
     */
    name?: string | null;
    bpmn_flow_path?: string | null;
    bpmn_version?: number | null;
    instance_created_at: string;
    instance_created_by: string;
    /**
     * When the token arrived at this element, from the engine's own
     * bounded history. Null for a park older than the retained history.
     *
     */
    parked_at?: string | null;
    /**
     * `flowable:assignee` / `<humanPerformer>`, when written as a literal
     */
    assignee?: string | null;
    owner?: string | null;
    candidate_users?: Array<(string)>;
    candidate_groups?: Array<(string)>;
    /**
     * The task declares an assignment written as an expression, which
     * this path cannot evaluate. The task is still listed (hiding it
     * would make it unreachable, which is the defect #1104 is about) but
     * a client must not present it as unassigned.
     *
     */
    assignment_unresolved?: boolean;
    /**
     * presentational only -- nothing schedules on it
     */
    due_date?: string | null;
    priority?: string | null;
    /**
     * `flowable:formKey`, reported but never resolved (#705 phase 4)
     */
    form_key?: string | null;
    form_fields?: Array<BpmnUserTaskFormField>;
    /**
     * the model set `flowable:formFieldValidation="false"`, so the server will not validate the payload
     */
    form_validation_disabled?: boolean;
};
/**
 * full instance detail -- lifecycle, active tokens/activities/joins/scopes, variables, and incidents
 */
export type BpmnInstanceDetail = {
    id: string;
    workspace_id: string;
    bpmn_flow_path?: string | null;
    bpmn_version?: number | null;
    created_at: string;
    created_by: string;
    started_at?: string | null;
    completed_at?: string | null;
    job_status?: string | null;
    canceled_by?: string | null;
    canceled_reason?: string | null;
    lifecycle?: 'running' | 'completed' | 'incident' | null;
    tokens?: Array<BpmnToken>;
    activities?: Array<BpmnActivityState>;
    joins?: Array<BpmnJoinState>;
    scopes?: Array<BpmnScope>;
    variables?: {
        [key: string]: unknown;
    };
    incidents?: Array<BpmnIncident>;
    result?: {
        [key: string]: unknown;
    };
};
/**
 * a token located at an element (never in transit on a sequence flow)
 */
export type BpmnToken = {
    id: string;
    element_id: string;
    scope_id: string;
    /**
     * the incoming sequence-flow id the token used to reach element_id
     */
    arrived_via?: string;
    state: BpmnTokenState;
};
/**
 * where a token is parked between step passes, tagged by `type`
 */
export type BpmnTokenState = {
    type: 'active' | 'waiting_for_job' | 'waiting_for_event' | 'waiting_for_timer' | 'waiting_for_scope' | 'async_before' | 'async_leave' | 'consumed';
    /**
     * only present when type = waiting_for_timer
     */
    fire_at?: string;
    /**
     * only present when type = waiting_for_scope
     */
    scope_id?: string;
    /**
     * only present when type = async_leave, and only when the element is an exclusive gateway that already chose its outgoing sequence flow: the id of that flow, so the continuation takes it without re-evaluating the gateway's conditions
     */
    via?: string;
};
/**
 * join accounting for a parallel (AND) or structured inclusive (OR) join
 */
export type BpmnJoinState = {
    join_id: string;
    scope_id: string;
    activation: number;
    expected: Array<(string)>;
    arrived: Array<(string)>;
};
/**
 * bookkeeping for one dispatched activity
 */
export type BpmnActivityState = {
    element_id: string;
    scope_id: string;
    token_id: string;
    /**
     * the dispatched child job id
     */
    job_id?: string;
    activation: number;
    state: BpmnActivityRunState;
};
/**
 * lifecycle of a single dispatched activity, tagged by `type`
 */
export type BpmnActivityRunState = {
    type: 'started' | 'completed' | 'failed';
};
/**
 * a sub-process activation
 */
export type BpmnScope = {
    id: string;
    element_id: string;
    parent_scope_id?: string;
    variables?: {
        [key: string]: unknown;
    };
    activation: number;
};
/**
 * a parked-process error the operator must see and can retry
 */
export type BpmnIncident = {
    kind: BpmnIncidentKind;
    activity_id?: string;
    message?: string;
    /**
     * the original failed child job's id -- this is the id used by POST .../incidents/{job_id}/retry
     */
    job?: string;
    at: string;
};
/**
 * One reason a (from_version, to_version) pair is not eligible for an identity migration (#922). `rule` is the discriminant; `rule_number` groups it (1 superset -- every v1 element id, sequence-flow id and message name exists in v2; 2 stable meaning -- an id that survives must still denote the same kind, scope, process, message binding and (for a boundary event) host activity; 3 join stability -- no element's set of incoming sequence flows may change, because `JoinState.expected` is derived once and never refreshed, so a stale one wedges the instance with no error at all). The remaining properties are the rule's own, and which are present depends on `rule`.
 */
export type BpmnMigrationBlocker = {
    rule: 'process_id_changed' | 'element_removed' | 'element_kind_changed' | 'element_scope_changed' | 'sequence_flow_removed' | 'message_name_removed' | 'message_binding_changed' | 'boundary_host_changed' | 'incoming_flows_changed';
    rule_number: number;
    /**
     * the rendered sentence, safe to show an operator as-is
     */
    message: string;
    element_id?: string;
    flow_id?: string;
    message_name?: string;
    kind?: string;
    from?: string;
    to?: string;
    removed?: Array<(string)>;
    added?: Array<(string)>;
};
/**
 * Whether an instance pinned to `from_version` may be repinned to `to_version`, and if not, why. A property of the pair, not of an instance.
 */
export type BpmnMigrationCheck = {
    from_version: number;
    to_version: number;
    bpmn_flow_path: string;
    eligible: boolean;
    blockers: Array<BpmnMigrationBlocker>;
};
/**
 * An operator's assertion about how a source version's elements correspond to a target version's (#925). Elements not named here are implicitly mapped to their own id -- and are then subject to every rule an explicit mapping is. 1:1 only: 1:N is deliberately not representable (it would require the engine to synthesize tokens, and inside an inclusive region the `JoinState` that `inclusive_join` never creates), and N:1 is representable only so that it can be refused with a reason.
 */
export type BpmnMigrationMapping = {
    activities?: Array<{
        /**
         * an element id in the source version
         */
        from: string;
        /**
         * an element id in the target version
         */
        to: string;
    }>;
};
/**
 * One reason a mapping document does not hold for a version pair (#925). `rule` is the discriminant; `rule_number` groups it (1 document well-formedness; 2 no silent drop -- an unmapped, deleted element would drop a token; 3 stable meaning -- kind, message binding and correlation names; 4 injectivity -- no N:1 merge, because a join's `arrived` is a set and would absorb the duplicate; 5 scope coherence; 6 edge images -- each source flow needs a unique counterpart between its mapped endpoints; 7 join coherence -- the only *silent* failure, since `JoinState.expected` is derived once and never refreshed; 8 boundary coherence -- the interruption surface of a running activity must not change under it). The remaining properties are the rule's own, and which are present depends on `rule`.
 */
export type BpmnMappingBlocker = {
    rule: 'unknown_source' | 'unknown_target' | 'duplicate_source' | 'activity_deleted' | 'mapped_kind_changed' | 'mapped_message_binding_changed' | 'message_name_removed' | 'activities_merged' | 'sequence_flows_merged' | 'mapped_scope_incoherent' | 'sequence_flow_unmapped' | 'sequence_flow_ambiguous' | 'mapped_incoming_flows_changed' | 'boundary_events_changed';
    rule_number: number;
    /**
     * the rendered sentence, safe to show an operator as-is
     */
    message: string;
    element_id?: string;
    flow_id?: string;
    message_name?: string;
    kind?: string;
    from?: string;
    to?: string;
    target?: string;
    target_flow?: string;
    from_kind?: string;
    to_kind?: string;
    from_message?: string;
    to_message?: string;
    expected_scope?: string;
    actual_scope?: string;
    mapped_source?: string;
    mapped_target?: string;
    sources?: Array<(string)>;
    targets?: Array<(string)>;
    candidates?: Array<(string)>;
    missing?: Array<(string)>;
    unexpected?: Array<(string)>;
};
/**
 * A validated, fully-resolved rewrite: every identifier substitution needed to move an instance's persisted state from the source version's vocabulary to the target's. Only entries that actually change are present, so an empty plan with equal process ids is exactly an identity migration.
 * A plan is necessary and **not sufficient**. Three things stand outside it: `ActivityState.external_worker` and `RetryState.max_attempts` are dispatch-time snapshots, frozen by decision; `history[]` records what actually executed under the ids it executed under, immutable by decision; and the eight `uuid_v5` derived key formats that embed element and flow ids are **not yet handled** -- every key of `elements` is an element whose derived child-job ids change, which the engine-side applier must re-key.
 */
export type BpmnMigrationPlan = {
    /**
     * the root `Scope.element_id` before the rewrite -- the root scope's element id *is* the `<process id>`, and is the only site carrying it, which is why a process-id rename is unambiguous under a document and is resolved rather than refused
     */
    from_process_id: string;
    to_process_id: string;
    /**
     * old element id -> new element id, changed entries only
     */
    elements?: {
        [key: string]: (string);
    };
    /**
     * old sequence-flow id -> new sequence-flow id, changed entries only. Derived by matching mapped endpoints, never declared.
     */
    sequence_flows?: {
        [key: string]: (string);
    };
};
/**
 * Whether a mapping document holds for a version pair, and the substitution it resolves to. Nothing is written by the operations that return this.
 */
export type BpmnMigrationPlanCheck = {
    from_version: number;
    to_version: number;
    bpmn_flow_path: string;
    /**
     * the mapping document holds against this pair
     */
    eligible: boolean;
    /**
     * the resolved plan rewrites nothing, so the pair is identity-migratable and `process_status` must not be touched
     */
    identity: boolean;
    /**
     * this migration can be performed with what exists today. Equal to `identity` until the engine-side applier lands -- a non-identity plan is validated but not yet applicable.
     */
    executable_today: boolean;
    plan?: BpmnMigrationPlan;
    blockers: Array<BpmnMappingBlocker>;
};
/**
 * One `bpmn_flow_version` with live instances pinned to it (#919), carrying the migratability verdict for (this version -> latest).
 */
export type BpmnPinnedVersionRollup = {
    /**
     * the `bpmn_flow_version.id` these instances resolve their model from
     */
    version: number;
    /**
     * null once the version row is gone
     */
    created_at?: string | null;
    created_by?: string | null;
    /**
     * live, uncancelled root instances pinned here
     */
    running_instances: number;
    is_latest: boolean;
    /**
     * how many newer deployed versions of this flow exist; 0 means latest. Null when this version is not in `bpmn_flow.versions` (typically because the flow row is not visible to the caller).
     */
    versions_behind?: number | null;
    /**
     * #922's verdict. Null when it was not computed -- because this is already latest, because `check=false`, because the response's check limit was reached, or because a definition would not resolve. `check_error` distinguishes those; a null is never a "no".
     */
    migratable_to_latest?: boolean | null;
    /**
     * every reason, named, when `migratable_to_latest` is false. Same shape the migrate endpoints refuse with, so one canvas rendering serves both. Omitted when empty.
     */
    blockers?: Array<BpmnMigrationBlocker>;
    /**
     * why there is no verdict. Omitted whenever there is one.
     */
    check_error?: string;
};
/**
 * one flow's live instances split across the versions they are pinned to
 */
export type BpmnFlowVersionRollup = {
    /**
     * the flow as it is named now, resolved through `bpmn_flow_version.path` so a rename does not produce a dead link
     */
    bpmn_flow_path: string;
    /**
     * what a new start would pin to. Null when the flow row is not visible to the caller or has no deployed version.
     */
    latest_version?: number | null;
    running_instances: number;
    /**
     * live instances not on `latest_version`
     */
    outdated_instances: number;
    /**
     * newest pinned version first
     */
    versions: Array<BpmnPinnedVersionRollup>;
};
/**
 * Running BPMN instances grouped by pinned definition version (#919) -- "we have 340 instances on 12 versions" in one response.
 */
export type BpmnVersionRollup = {
    /**
     * most outdated instances first, then most instances, then path
     */
    flows: Array<BpmnFlowVersionRollup>;
    running_instances: number;
    outdated_instances: number;
    /**
     * distinct (flow, pinned version) groups
     */
    pinned_versions: number;
    /**
     * live root instances that resolve to no `bpmn_flow_version` at all. Preview runs are excluded outright, so this is normally zero; it is reported so the totals reconcile against `/instances/list`.
     */
    unattributed_instances: number;
    /**
     * true when the response's per-version check limit was reached and some versions carry no verdict for that reason alone
     */
    checks_truncated: boolean;
};
/**
 * what a migrate call actually moved
 */
export type BpmnMigrationResult = {
    from_version: number;
    to_version: number;
    bpmn_flow_path: string;
    dry_run: boolean;
    /**
     * the instance ids repinned; empty for a dry run
     */
    migrated: Array<(string)>;
};
/**
 * The 400 body when the contract refuses a swap. Same envelope shape as deploy-time BPMN validation (#743): `error` is a readable sentence for a client that reads one field, `blockers` carries the structure a UI needs to mark the offending shapes.
 */
export type BpmnMigrationRefusal = {
    error: string;
    from_version?: number;
    to_version?: number;
    blockers?: Array<BpmnMigrationBlocker>;
};
/**
 * why a process parked in ProcessLifecycle::Incident, tagged by `type`
 */
export type BpmnIncidentKind = {
    type: 'activity_failed' | 'join_starved' | 'no_outgoing_path' | 'unsupported_element' | 'engine_error' | 'stranded';
};
/**
 * Frontend-facing projection of a process instance's live runtime state (Phase 5 Task 3) -- lifecycle, per-activity status, variables, history, and incidents. Consumed by the live process token overlay via GET .../instances/get/{id}/status.
 */
export type ProcessInstanceStatus = {
    instance_id: string;
    process_status: ProcessStatusValue;
    updated_at: string;
    activities: Array<ProcessActivityStatus>;
    variables: {
        [key: string]: unknown;
    };
    history: Array<ProcessHistoryEntry>;
    incidents: Array<ProcessIncident>;
};
/**
 * overall status of one process instance, as surfaced to the frontend
 */
export type ProcessStatusValue = 'running' | 'completed' | 'failed' | 'suspended' | 'canceled';
/**
 * runtime state of one BPMN element, as surfaced to the frontend overlay
 */
export type ProcessActivityRuntimeState = 'active' | 'completed' | 'failed' | 'terminated';
/**
 * error detail attached to a failed ProcessActivityStatus
 */
export type ProcessActivityError = {
    message: string;
    child_job_id?: string;
};
/**
 * automatic-retry detail attached to a ProcessActivityStatus. Present only when the element's most recent dispatch carried a retry policy. next_attempt_at set means the activity failed and is waiting to be retried at that instant -- the process is running, not broken, and no incident exists yet. next_attempt_at absent with attempt == max_attempts means the budget is spent; if the element also carries an error, that is the dead-lettered activity.
 */
export type ProcessActivityRetry = {
    /**
     * 1-based; 1 is the original execution
     */
    attempt: number;
    /**
     * total attempts permitted, original included
     */
    max_attempts: number;
    next_attempt_at?: string;
};
/**
 * one element's projected runtime status
 */
export type ProcessActivityStatus = {
    element_id: string;
    state: ProcessActivityRuntimeState;
    token_count: number;
    error?: ProcessActivityError;
    entered_at?: string;
    left_at?: string;
    retry?: ProcessActivityRetry;
};
/**
 * one open, operator-facing incident (flattened projection)
 */
export type ProcessIncident = {
    element_id: string;
    message: string;
    child_job_id?: string;
};
/**
 * one per-element transition record. Not currently populated by the engine -- always an empty array today (see ProcessInstanceStatus).
 */
export type ProcessHistoryEntry = {
    element_id: string;
    transition: string;
    /**
     * why this transition is not what it looks like. Set only by a `noop` delegate binding today (#923): the activity reports `completed` without having run anything, and this carries the binding's mandatory reason.
     */
    note?: string;
    at: string;
};
export type DmnDecision = {
    workspace_id: string;
    path: string;
    summary: string;
    description: string;
    /**
     * The DMN 1.3 XML
     */
    value: string;
    edited_by: string;
    edited_at: string;
    archived: boolean;
    extra_perms: ExtraPerms;
    draft_only?: boolean;
    labels?: Array<(string)>;
    versions: Array<(number)>;
};
export type NewDmnDecision = {
    path: string;
    summary: string;
    description?: string;
    /**
     * The DMN 1.3 XML
     */
    value: string;
    draft_only?: boolean;
    labels?: Array<(string)>;
};
export type ListableDmnDecision = {
    workspace_id: string;
    path: string;
    summary: string;
    description?: string;
    edited_by: string | null;
    edited_at: string | null;
    archived: boolean;
    extra_perms: ExtraPerms;
    has_draft: boolean;
    draft_only?: boolean;
    labels?: Array<(string)>;
};
export type DmnDecisionWithDraft = {
    path: string;
    summary: string;
    description: string;
    /**
     * The DMN 1.3 XML
     */
    value: string;
    extra_perms: ExtraPerms;
    draft_only?: boolean;
    draft?: {
        [key: string]: unknown;
    };
    labels?: Array<(string)>;
};
export type DmnDecisionVersion = {
    id: number;
    workspace_id: string;
    path: string;
    /**
     * The DMN 1.3 XML at this version
     */
    value: string | null;
    created_by: string;
    created_at: string;
};
export type EvaluateRequest = {
    /**
     * A saved dmn_decision path to load and evaluate
     */
    decision_id?: string;
    /**
     * Input values keyed by FEEL variable name (an input column's `inputExpression` text).
     * A nested object is flattened into dotted keys -- `{"applicant": {"age": 35}}` supplies
     * `applicant.age` -- the same mapping a running BPMN businessRuleTask applies to its
     * process variables, so a decision evaluates identically here and in production.
     *
     */
    inputs: {
        [key: string]: unknown;
    };
    /**
     * Inline DMN 1.3 XML to evaluate instead of a saved decision_id
     */
    xml?: string;
    /**
     * In-document `<decision id>` selector, separate from decision_id (which is the storage
     * path when loading a saved decision). When set, selects which decision inside the
     * document to evaluate -- e.g. a decision other than the first in a saved multi-decision
     * document. When omitted, inline xml falls back to decision_id as its selector and a
     * stored decision evaluates its first decision element. Optional and backwards-compatible.
     *
     */
    decision_ref?: string;
};
export type EvaluateResponse = {
    hit_policy: string;
    /**
     * The COLLECT aggregator that ran (DMN tBuiltinAggregator). Absent for every hit policy
     * other than COLLECT, and for a plain un-aggregated COLLECT. When present, outputs holds
     * a scalar per output column instead of the array a plain COLLECT returns.
     *
     */
    aggregation?: 'SUM' | 'MIN' | 'MAX' | 'COUNT';
    /**
     * 1-based rule numbers, in the order the hit policy selected them
     */
    matched_rules: Array<(number)>;
    /**
     * Output values keyed by output column name (COLLECT yields an array per key)
     */
    outputs: {
        [key: string]: unknown;
    };
    /**
     * Inputs that have no FEEL representation and were therefore absent from the context this
     * decision was evaluated against, each as "`name`: reason". Omitted rather than fatal, so
     * that the API and a running businessRuleTask evaluate the same decision identically.
     * Absent when everything mapped.
     *
     */
    unmapped_inputs?: Array<(string)>;
};
/**
 * Evaluate one `<decisionService>` -- the whole DRD closure below it -- as a unit
 * (Flowable part2). Deliberately a separate shape from EvaluateRequest: a decision
 * service has no single hit_policy and no single matched_rules, so folding it into
 * EvaluateResponse would leave two of that schema's three required fields meaningless.
 *
 */
export type EvaluateServiceRequest = {
    /**
     * A saved dmn_decision path whose document holds the decision service
     */
    decision_id?: string;
    /**
     * Inline DMN 1.3 XML to evaluate instead of a saved decision_id
     */
    xml?: string;
    /**
     * The in-document `<decisionService id>` to run. Optional only when the document
     * declares exactly one decision service, which is then resolved automatically (the
     * same rule a BPMN decision task already applies to a `decisionServiceReference` that
     * carries no in-document selector). Two or more, and the request is rejected with
     * every declared service id named: picking the first would make which one ran depend
     * on element order.
     *
     */
    decision_service_ref?: string;
    /**
     * Input values keyed by FEEL variable name, flattened into dotted keys exactly as for
     * EvaluateRequest. Each decision's result is then bound into the same context twice:
     * under each output column's bare name (Flowable parity -- Flowable merges results flat
     * into one shared variable map and never reads `<variable>`), and under the decision's
     * own `<variable name>` (single output) or `<variable name>.<column>` (several outputs),
     * which cannot collide.
     *
     */
    inputs: {
        [key: string]: unknown;
    };
};
export type EvaluatedDecisionSummary = {
    decision_id: string;
    decision_name: string;
    /**
     * The `<variable name>` this decision's result was bound under
     */
    variable: string;
    /**
     * True for an `<outputDecision>` of the service, false for an `<encapsulatedDecision>`
     * whose result feeds other decisions but is not returned.
     *
     */
    is_output: boolean;
    hit_policy: string;
    aggregation?: 'SUM' | 'MIN' | 'MAX' | 'COUNT';
    matched_rules: Array<(number)>;
    /**
     * The decision's result as a value: the scalar for a single-output table, a
     * {column: value} object for a multi-output one, null when no rule matched
     * (DMN 1.3 section 8.2.11 / Table 44).
     *
     */
    value: unknown;
};
export type EvaluateServiceResponse = {
    service_id: string;
    /**
     * One `<outputDecision>` returns that decision's value directly; several return an
     * object keyed by each one's `<variable name>`.
     *
     */
    outputs: unknown;
    /**
     * Every decision that ran, in topological order -- the audit trail of a DRD run, and
     * the only way to see why an output came out as it did when several tables fed into it.
     *
     */
    decisions: Array<EvaluatedDecisionSummary>;
    /**
     * Declared `<inputData>` that a decision in the closure required via a
     * `<requiredInput>` edge but that the request did not supply. A warning, not an error:
     * a missing name evaluates to null, exactly as everywhere else in this engine.
     *
     */
    missing_inputs?: Array<(string)>;
    /**
     * Bare output-column names that one decision's result overwrote after an earlier
     * decision (or the request) had already bound them. This is Flowable's documented
     * behaviour -- one shared variable map, last write wins -- kept for parity but reported
     * rather than silent. The namespaced `<variable name>` binding is unaffected, so the
     * shadowed value is still reachable.
     *
     */
    shadowed_variables?: Array<(string)>;
    unmapped_inputs?: Array<(string)>;
};
export type SlackToken = {
    access_token: string;
    team?: {
        id: string;
        name: string;
    };
};
export type TokenResponse = {
    access_token: string;
    expires_in?: number;
    refresh_token?: string;
    scope?: Array<(string)>;
    grant_type?: string;
};
export type HubScriptKind = 'script' | 'failure' | 'trigger' | 'approval';
export type PolarsClientKwargs = {
    region_name: string;
};
export type LargeFileStorage = {
    type?: 'S3Storage' | 'AzureBlobStorage' | 'AzureWorkloadIdentity' | 'S3AwsOidc' | 'GoogleCloudStorage';
    s3_resource_path?: string;
    azure_blob_resource_path?: string;
    gcs_resource_path?: string;
    public_resource?: boolean;
    advanced_permissions?: Array<S3PermissionRule>;
    secondary_storage?: {
        [key: string]: {
            type?: 'S3Storage' | 'AzureBlobStorage' | 'AzureWorkloadIdentity' | 'S3AwsOidc' | 'GoogleCloudStorage';
            s3_resource_path?: string;
            azure_blob_resource_path?: string;
            gcs_resource_path?: string;
            public_resource?: boolean;
        };
    };
};
export type DucklakeSettings = {
    ducklakes: {
        [key: string]: {
            catalog: {
                resource_type: 'postgresql' | 'mysql' | 'instance';
                resource_path?: string;
            };
            storage: {
                storage?: string;
                path: string;
            };
            extra_args?: string;
        };
    };
};
export type DataTableSettings = {
    datatables: {
        [key: string]: {
            database: {
                resource_type: 'postgresql' | 'instance';
                resource_path?: string;
            };
            /**
             * Fork origin info with schema snapshot
             */
            forked_from?: {
                /**
                 * Schema snapshot at fork time
                 */
                schema?: {
                    [key: string]: unknown;
                };
            };
        };
    };
};
export type DataTableSchema = {
    datatable_name: string;
    /**
     * Hierarchical schema: schema_name -> table_name -> column_name -> compact_type (e.g. 'int4', 'text?', 'int4?=0')
     */
    schemas: {
        [key: string]: {
            [key: string]: {
                [key: string]: (string);
            };
        };
    };
    error?: string;
};
export type DataTableTables = {
    datatable_name: string;
    /**
     * Hierarchical metadata: schema_name -> table_names
     */
    schemas: {
        [key: string]: Array<(string)>;
    };
    error?: string;
};
export type DataTableTableSchema = {
    datatable_name: string;
    schema_name: string;
    table_name: string;
    /**
     * Columns in this table: column_name -> compact_type
     */
    columns: {
        [key: string]: (string);
    };
};
export type DynamicInputData = {
    /**
     * Name of the function to execute for dynamic select
     */
    entrypoint_function: string;
    /**
     * Arguments to pass to the function
     */
    args?: {
        [key: string]: unknown;
    };
    runnable_ref: {
        source: 'deployed';
        /**
         * Path to the deployed script or flow
         */
        path: string;
        runnable_kind: RunnableKind;
    } | {
        source: 'inline';
        /**
         * Code content for inline execution
         */
        code: string;
        language?: ScriptLang;
    };
};
export type OrvantaLargeFile = {
    s3: string;
};
export type OrvantaFileMetadata = {
    mime_type?: string;
    size_in_bytes?: number;
    last_modified?: string;
    expires?: string;
    version_id?: string;
};
export type OrvantaFilePreview = {
    msg?: string;
    content?: string;
    content_type: 'RawText' | 'Csv' | 'Parquet' | 'Unknown';
};
export type S3Resource = {
    bucket: string;
    region: string;
    endPoint: string;
    useSSL: boolean;
    accessKey?: string;
    secretKey?: string;
    pathStyle: boolean;
};
export type WorkspaceGitSyncSettings = {
    repositories?: Array<GitRepositorySettings>;
};
export type WorkspaceDeployUISettings = {
    include_path?: Array<(string)>;
    include_type?: Array<GitSyncObjectType>;
};
export type WorkspaceDefaultScripts = {
    order?: Array<(string)>;
    hidden?: Array<(string)>;
    default_script_content?: unknown;
};
export type S3PermissionRule = {
    pattern: string;
    allow: string;
};
export type GitRepositorySettings = {
    script_path?: string;
    git_repo_resource_path: string;
    use_individual_branch?: boolean;
    group_by_folder?: boolean;
    collapsed?: boolean;
    settings?: {
        include_path?: Array<(string)>;
        include_type?: Array<GitSyncObjectType>;
        exclude_path?: Array<(string)>;
        extra_include_path?: Array<(string)>;
    };
    exclude_types_override?: Array<GitSyncObjectType>;
};
export type MetricMetadata = {
    id: string;
    name?: string;
};
export type ScalarMetric = {
    metric_id?: string;
    value: number;
};
export type TimeseriesMetric = {
    metric_id?: string;
    values: Array<MetricDataPoint>;
};
export type MetricDataPoint = {
    timestamp: string;
    value: number;
};
export type RawScriptForDependencies = {
    raw_code: string;
    path: string;
    language: ScriptLang;
};
export type ConcurrencyGroup = {
    concurrency_key: string;
    total_running: number;
};
export type ExtendedJobs = {
    jobs: Array<Job>;
    obscured_jobs: Array<ObscuredJob>;
    /**
     * Obscured jobs omitted for security because of too specific filtering
     */
    omitted_obscured_jobs?: boolean;
};
export type ExportedUser = {
    email: string;
    password_hash?: string;
    super_admin: boolean;
    verified: boolean;
    name?: string;
    company?: string;
    first_time_user: boolean;
    username?: string;
};
export type GlobalSetting = {
    name: string;
    value: unknown;
};
/**
 * Instance-wide usage of one language (#190/#255 runtime governance).
 */
export type RuntimeUsageCount = {
    language: string;
    scripts: number;
    flows: number;
    apps: number;
};
/**
 * One concrete usage of a language (#190/#255 runtime governance).
 */
export type RuntimeUsageLocation = {
    kind: 'script' | 'flow' | 'app';
    workspace_id: string;
    path: string;
};
/**
 * Unified instance configuration combining global settings and worker group configs
 */
export type InstanceConfig = {
    /**
     * Global settings keyed by setting name. Known fields include base_url, license_key, retention_period_secs, smtp_settings, otel, etc. Unknown fields are preserved as-is.
     *
     */
    global_settings?: {
        [key: string]: unknown;
    };
    /**
     * Worker group configurations keyed by group name (e.g. "default", "gpu"). Each value contains worker_tags, init_bash, autoscaling, etc.
     *
     */
    worker_configs?: {
        [key: string]: {
            [key: string]: unknown;
        };
    };
};
export type Config = {
    name: string;
    config?: {
        [key: string]: unknown;
    };
};
export type ExportedInstanceGroup = {
    name: string;
    summary?: string;
    emails?: Array<(string)>;
    id?: string;
    scim_display_name?: string;
    external_id?: string;
    instance_role?: 'superadmin' | 'devops' | null;
};
/**
 * A matched completed run. `document` is Tantivy's native `{field: [values, ...]}` shape (every field is multi-valued), with keys `id`, `workspace_id`, `script_path`, `success`, `created_at`.
 */
export type JobSearchHit = {
    document?: {
        [key: string]: unknown;
    };
    /**
     * Stable per-hit id (the job id) for selection/dedup in the UI.
     */
    search_id?: string;
};
/**
 * A matched service-log line. `document` is Tantivy's native `{field: [values, ...]}` shape, with keys `host`, `mode`, `worker_group`, `file_name`, `line_number`, `timestamp`, `json_fmt`, `logs`.
 */
export type LogSearchHit = {
    document?: {
        [key: string]: unknown;
    };
    /**
     * Plain-text excerpt around the match, if a snippet could be generated.
     */
    snippet_fragment?: string | null;
    /**
     * Character ranges within `snippet_fragment` to highlight.
     */
    snippet_highlighted?: Array<{
        start?: number;
        end?: number;
    }>;
};
export type AutoscalingEvent = {
    id?: number;
    worker_group?: string;
    event_type?: string;
    desired_workers?: number;
    reason?: string;
    applied_at?: string;
};
export type CriticalAlert = {
    /**
     * Unique identifier for the alert
     */
    id?: number;
    /**
     * Type of alert (e.g., critical_error)
     */
    alert_type?: string;
    /**
     * The message content of the alert
     */
    message?: string;
    /**
     * Time when the alert was created
     */
    created_at?: string;
    /**
     * Acknowledgment status of the alert, can be true, false, or null if not set
     */
    acknowledged?: boolean | null;
    /**
     * Workspace id if the alert is in the scope of a workspace
     */
    workspace_id?: string | null;
};
export type CaptureTriggerKind = 'webhook' | 'http' | 'websocket' | 'kafka' | 'default_email' | 'nats' | 'postgres' | 'sqs' | 'mqtt' | 'gcp' | 'azure' | 'email';
export type Capture = {
    trigger_kind: CaptureTriggerKind;
    main_args: unknown;
    preprocessor_args: unknown;
    id: number;
    created_at: string;
};
export type CaptureConfig = {
    trigger_config?: unknown;
    trigger_kind: CaptureTriggerKind;
    error?: string;
    last_server_ping?: string;
};
export type OperatorSettings = {
    /**
     * Whether operators can view runs
     */
    runs: boolean;
    /**
     * Whether operators can view schedules
     */
    schedules: boolean;
    /**
     * Whether operators can view resources
     */
    resources: boolean;
    /**
     * Whether operators can view variables
     */
    variables: boolean;
    /**
     * Whether operators can view assets
     */
    assets: boolean;
    /**
     * Whether operators can view audit logs
     */
    audit_logs: boolean;
    /**
     * Whether operators can view triggers
     */
    triggers: boolean;
    /**
     * Whether operators can view groups page
     */
    groups: boolean;
    /**
     * Whether operators can view folders page
     */
    folders: boolean;
    /**
     * Whether operators can view workers page
     */
    workers: boolean;
} | null;
export type WorkspaceComparison = {
    /**
     * All items with changes ahead are visible by the user of the request.
     */
    all_ahead_items_visible: boolean;
    /**
     * All items with changes behind are visible by the user of the request.
     */
    all_behind_items_visible: boolean;
    /**
     * Whether the comparison was skipped. This happens with old forks that where not being kept track of
     */
    skipped_comparison: boolean;
    /**
     * List of differences found between workspaces
     */
    diffs: Array<WorkspaceItemDiff>;
    /**
     * Summary statistics of the comparison
     */
    summary: CompareSummary;
};
export type WorkspaceItemDiff = {
    /**
     * Type of the item
     */
    kind: 'script' | 'flow' | 'app' | 'raw_app' | 'resource' | 'variable' | 'resource_type' | 'folder' | 'schedule' | 'http_trigger' | 'websocket_trigger' | 'kafka_trigger' | 'nats_trigger' | 'postgres_trigger' | 'mqtt_trigger' | 'sqs_trigger' | 'gcp_trigger' | 'azure_trigger' | 'email_trigger';
    /**
     * Path of the item in the workspace
     */
    path: string;
    /**
     * Number of versions source is ahead of target
     */
    ahead: number;
    /**
     * Number of versions source is behind target
     */
    behind: number;
    /**
     * Whether the item has any differences
     */
    has_changes: boolean;
    /**
     * If the item exists in the source workspace
     */
    exists_in_source: boolean;
    /**
     * If the item exists in the fork workspace
     */
    exists_in_fork: boolean;
};
export type CompareSummary = {
    /**
     * Total number of items with differences
     */
    total_diffs: number;
    /**
     * Total number of ahead changes
     */
    total_ahead: number;
    /**
     * Total number of behind changes
     */
    total_behind: number;
    /**
     * Number of scripts with differences
     */
    scripts_changed: number;
    /**
     * Number of flows with differences
     */
    flows_changed: number;
    /**
     * Number of apps with differences
     */
    apps_changed: number;
    /**
     * Number of resources with differences
     */
    resources_changed: number;
    /**
     * Number of variables with differences
     */
    variables_changed: number;
    /**
     * Number of resource types with differences
     */
    resource_types_changed: number;
    /**
     * Number of folders with differences
     */
    folders_changed: number;
    /**
     * Number of schedules with differences
     */
    schedules_changed: number;
    /**
     * Number of triggers with differences (sum across all trigger kinds)
     */
    triggers_changed: number;
    /**
     * Number of items that are both ahead and behind (conflicts)
     */
    conflicts: number;
};
export type TeamInfo = {
    /**
     * The unique identifier of the Microsoft Teams team
     */
    team_id: string;
    /**
     * The display name of the Microsoft Teams team
     */
    team_name: string;
    /**
     * List of channels within the team
     */
    channels: Array<ChannelInfo>;
};
export type ChannelInfo = {
    /**
     * The unique identifier of the channel
     */
    channel_id: string;
    /**
     * The display name of the channel
     */
    channel_name: string;
    /**
     * The Microsoft Teams tenant identifier
     */
    tenant_id: string;
    /**
     * The service URL for the channel
     */
    service_url: string;
};
export type GithubInstallations = Array<{
    workspace_id?: string;
    installation_id: number;
    account_id: string;
    repositories: Array<{
        name: string;
        url: string;
    }>;
    /**
     * Total number of repositories available for this installation
     */
    total_count: number;
    /**
     * Number of repositories loaded per page
     */
    per_page: number;
    /**
     * Error message if token retrieval failed
     */
    error?: string;
}>;
export type WorkspaceGithubInstallation = {
    account_id: string;
    installation_id: number;
};
export type S3Object = {
    s3: string;
    filename?: string;
    storage?: string;
    presigned?: string;
};
export type TeamsChannel = {
    /**
     * Microsoft Teams team ID
     */
    team_id: string;
    /**
     * Microsoft Teams team name
     */
    team_name: string;
    /**
     * Microsoft Teams channel ID
     */
    channel_id: string;
    /**
     * Microsoft Teams channel name
     */
    channel_name: string;
};
export type AssetUsageKind = 'script' | 'flow' | 'job';
export type AssetUsageAccessType = 'r' | 'w' | 'rw';
export type AssetKind = 's3object' | 'resource' | 'ducklake' | 'datatable' | 'volume';
export type Asset = {
    path: string;
    kind: AssetKind;
};
export type Volume = {
    name: string;
    size_bytes: number;
    file_count: number;
    created_at: string;
    created_by: string;
    updated_at?: string | null;
    last_used_at?: string | null;
    extra_perms?: {
        [key: string]: unknown;
    };
};
/**
 * A workspace protection rule defining restrictions and bypass permissions
 */
export type ProtectionRuleset = {
    /**
     * Unique name for the protection rule
     */
    name: string;
    workspace_id?: string;
    rules: ProtectionRules;
    bypass_groups: RuleBypasserGroups;
    bypass_users: RuleBypasserUsers;
};
/**
 * Configuration of protection restrictions
 */
export type ProtectionRules = Array<ProtectionRuleKind>;
export type ProtectionRuleKind = 'DisableDirectDeployment' | 'DisableWorkspaceForking' | 'RestrictDeployToDeployers';
/**
 * Groups that can bypass this ruleset
 */
export type RuleBypasserGroups = Array<(string)>;
/**
 * Users that can bypass this ruleset
 */
export type RuleBypasserUsers = Array<(string)>;
export type DeploymentRequestEligibleDeployer = {
    username: string;
    email: string;
    is_admin: boolean;
};
export type DeploymentRequestAssignee = {
    username: string;
    email: string;
};
export type DeploymentRequestComment = {
    id: number;
    parent_id?: number | null;
    author: string;
    author_email: string;
    body: string;
    anchor_kind?: string | null;
    anchor_path?: string | null;
    obsolete: boolean;
    created_at: string;
};
export type DeploymentRequest = {
    id: number;
    source_workspace_id: string;
    fork_workspace_id: string;
    requested_by: string;
    requested_by_email: string;
    requested_at: string;
    assignees: Array<DeploymentRequestAssignee>;
    comments: Array<DeploymentRequestComment>;
};
export type QuotaInfo = {
    used: number;
    limit: number;
    prunable: number;
};
export type NativeServiceName = 'nextcloud' | 'google' | 'github';
/**
 * A native trigger stored in Orvanta
 */
export type NativeTrigger = {
    /**
     * The unique identifier from the external service
     */
    external_id: string;
    /**
     * The workspace this trigger belongs to
     */
    workspace_id: string;
    service_name: NativeServiceName;
    /**
     * The path to the script or flow that will be triggered
     */
    script_path: string;
    /**
     * Whether the trigger targets a flow (true) or a script (false)
     */
    is_flow: boolean;
    /**
     * Configuration for the trigger including event_type and service_config
     */
    service_config: {
        [key: string]: unknown;
    };
    /**
     * Error message if the trigger is in an error state
     */
    error?: string | null;
    /**
     * Short summary to be displayed when listed
     */
    summary?: string | null;
};
/**
 * Full trigger response containing both Orvanta data and external service data
 */
export type NativeTriggerWithExternal = {
    /**
     * The unique identifier from the external service
     */
    external_id: string;
    /**
     * The workspace this trigger belongs to
     */
    workspace_id: string;
    service_name: NativeServiceName;
    /**
     * The path to the script or flow that will be triggered
     */
    script_path: string;
    /**
     * Whether the trigger targets a flow (true) or a script (false)
     */
    is_flow: boolean;
    /**
     * Configuration for the trigger including event_type and service_config
     */
    service_config: {
        [key: string]: unknown;
    };
    /**
     * Error message if the trigger is in an error state
     */
    error?: string | null;
    /**
     * Short summary to be displayed when listed
     */
    summary?: string | null;
    /**
     * Configuration data from the external service
     */
    external_data: {
        [key: string]: unknown;
    };
};
export type WorkspaceIntegrations = {
    service_name: NativeServiceName;
    oauth_data?: WorkspaceOAuthConfig | null;
    /**
     * Path to the resource storing the OAuth token
     */
    resource_path?: string | null;
};
export type WorkspaceOAuthConfig = {
    /**
     * The OAuth client ID for the workspace
     */
    client_id: string;
    /**
     * The OAuth client secret for the workspace
     */
    client_secret: string;
    /**
     * The base URL of the workspace
     */
    base_url: string;
    /**
     * The OAuth redirect URI
     */
    redirect_uri: string;
};
export type WebhookEvent = {
    type: 'webhook';
    request_type: WebhookRequestType;
};
/**
 * The type of webhook request (define possible values here)
 */
export type WebhookRequestType = 'async' | 'sync';
export type RedirectUri = {
    redirect_uri: string;
};
/**
 * Data for creating or updating a native trigger
 */
export type NativeTriggerData = {
    /**
     * The path to the script or flow that will be triggered
     */
    script_path: string;
    /**
     * Whether the trigger targets a flow (true) or a script (false)
     */
    is_flow: boolean;
    /**
     * Service-specific configuration (e.g., event types, filters)
     */
    service_config: {
        [key: string]: unknown;
    };
    /**
     * Short summary to be displayed when listed
     */
    summary?: string | null;
};
/**
 * Response returned when a native trigger is created
 */
export type CreateTriggerResponse = {
    /**
     * The external ID of the created trigger from the external service
     */
    external_id: string;
};
export type SyncResult = {
    already_in_sync: boolean;
    added_count: number;
    added_triggers: Array<(string)>;
    total_external: number;
    total_orvanta: number;
};
export type NextCloudEventType = {
    id: string;
    name: string;
    description?: string;
    category?: string;
    path: string;
};
export type GoogleCalendarEntry = {
    id: string;
    summary: string;
    primary?: boolean;
};
export type GoogleDriveFile = {
    id: string;
    name: string;
    mime_type: string;
    is_folder?: boolean;
};
export type GoogleDriveFilesResponse = {
    files: Array<GoogleDriveFile>;
    next_page_token?: string;
};
export type SharedDriveEntry = {
    id: string;
    name: string;
};
export type GithubRepoEntry = {
    full_name: string;
    name: string;
    owner: string;
    private: boolean;
};
export type ParameterId = string;
export type ParameterKey = string;
export type ParameterWorkspaceId = string;
/**
 * The name of the publication
 */
export type ParameterPublicationName = string;
export type ParameterVersionId = number;
export type ParameterToken = string;
export type ParameterAccountId = number;
export type ParameterClientName = string;
export type ParameterScriptPath = string;
export type ParameterScriptHash = string;
export type ParameterJobId = string;
/**
 * the failed child job id identifying the incident to retry (Incident.job)
 */
export type ParameterIncidentJobId = string;
export type ParameterPath = string;
export type ParameterCustomPath = string;
export type ParameterPathId = number;
export type ParameterPathVersion = number;
export type ParameterName = string;
/**
 * which page to return (start at 1, default 1)
 */
export type ParameterPage = number;
/**
 * number of items to return for a given page (default 30, max 100)
 */
export type ParameterPerPage = number;
/**
 * filter by trigger kind. Supports comma-separated list (e.g. 'schedule,webhook') and negation by prefixing all values with '!' (e.g. '!schedule,!webhook')
 */
export type ParameterJobTriggerKind = string;
/**
 * order by desc order (default true)
 */
export type ParameterOrderDesc = boolean;
/**
 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
 */
export type ParameterCreatedBy = string;
/**
 * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
 */
export type ParameterLabel = string;
/**
 * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
 */
export type ParameterWorker = string;
/**
 * The parent job that is at the origin and responsible for the execution of this script if any
 */
export type ParameterParentJob = string;
/**
 * Override the tag to use
 */
export type ParameterWorkerTag = string;
/**
 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
 */
export type ParameterCacheTtl = string;
/**
 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
 */
export type ParameterNewJobId = string;
/**
 * List of headers's keys (separated with ',') whove value are added to the args
 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
 *
 */
export type ParameterIncludeHeader = string;
/**
 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
 *
 */
export type ParameterQueueLimit = string;
/**
 * skip the preprocessor
 */
export type ParameterSkipPreprocessor = boolean;
/**
 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
 *
 */
export type ParameterPayload = string;
/**
 * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
 */
export type ParameterScriptStartPath = string;
/**
 * mask to filter by schedule path
 */
export type ParameterSchedulePath = string;
/**
 * filter by trigger path. Supports comma-separated list (e.g. 'f/trigger1,f/trigger2') and negation by prefixing all values with '!' (e.g. '!f/trigger1,!f/trigger2')
 */
export type ParameterTriggerPath = string;
/**
 * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
 */
export type ParameterScriptExactPath = string;
/**
 * mask to filter exact matching path
 */
export type ParameterScriptExactHash = string;
/**
 * filter on created before (inclusive) timestamp
 */
export type ParameterCreatedBefore = string;
/**
 * filter on created after (exclusive) timestamp
 */
export type ParameterCreatedAfter = string;
/**
 * filter on started before (inclusive) timestamp
 */
export type ParameterStartedBefore = string;
/**
 * filter on started after (exclusive) timestamp
 */
export type ParameterStartedAfter = string;
/**
 * filter on started before (inclusive) timestamp
 */
export type ParameterBefore = string;
/**
 * filter on started before (inclusive) timestamp
 */
export type ParameterCompletedBefore = string;
/**
 * filter on started after (exclusive) timestamp
 */
export type ParameterCompletedAfter = string;
/**
 * filter on jobs created after X for jobs in the queue only
 */
export type ParameterCreatedAfterQueue = string;
/**
 * filter on jobs created before X for jobs in the queue only
 */
export type ParameterCreatedBeforeQueue = string;
/**
 * filter on successful jobs
 */
export type ParameterSuccess = boolean;
/**
 * filter on jobs scheduled_for before now (hence waitinf for a worker)
 */
export type ParameterScheduledForBeforeNow = boolean;
/**
 * filter on suspended jobs
 */
export type ParameterSuspended = boolean;
/**
 * filter on running jobs
 */
export type ParameterRunning = boolean;
/**
 * allow wildcards (*) in the filter of label, tag, worker
 */
export type ParameterAllowWildcards = boolean;
/**
 * filter on jobs containing those args as a json subset (@> in postgres)
 */
export type ParameterArgsFilter = string;
/**
 * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
 */
export type ParameterTag = string;
/**
 * filter on jobs containing those result as a json subset (@> in postgres)
 */
export type ParameterResultFilter = string;
/**
 * filter on created after (exclusive) timestamp
 */
export type ParameterAfter = string;
/**
 * filter on exact username of user
 */
export type ParameterUsername = string;
/**
 * filter on exact or prefix name of operation
 */
export type ParameterOperation = string;
/**
 * filter on exact or prefix name of resource
 */
export type ParameterResourceName = string;
/**
 * filter on type of operation
 */
export type ParameterActionKind = 'Create' | 'Update' | 'Delete' | 'Execute';
/**
 * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
 */
export type ParameterJobKinds = string;
export type ParameterRunnableId = string;
export type ParameterRunnableTypeQuery = RunnableType;
export type ParameterInputId = string;
export type ParameterGetStarted = boolean;
export type ParameterConcurrencyId = string;
export type ParameterRunnableKind = 'script' | 'flow';
export type BackendVersionResponse = string;
export type ListFeaturesResponse = {
    keys: Array<(string)>;
    beta: boolean;
    /**
     * one entry per capability this build actually carries (present in the binary and enabled for this deployment's flavour). Capabilities the binary does not implement are omitted entirely. Additive and deliberately NOT in `required` (#729): during a rolling upgrade an old backend predating this field won't send it, and a generated client that required it would mis-type a valid response as invalid.
     */
    features?: Array<{
        key: string;
        label: string;
        group: string;
        /**
         * the raw catalog flag. `false` here means the entry is only visible because ORVANTA_BETA is on.
         */
        built: boolean;
        min_tier: 'trial' | 'teams' | 'enterprise';
        /**
         * whether the live licence clears `min_tier`
         */
        entitled: boolean;
        /**
         * fully usable; the filter that reproduces `keys`
         */
        available: boolean;
    }>;
};
export type GetLicenseIdResponse = string;
export type GetEntitlementsResponse = {
    tier: 'trial' | 'teams' | 'enterprise';
    edition: 'ote' | 'oee';
    expires_at?: string | null;
    limits?: {
        [key: string]: unknown;
    };
};
export type GetOpenApiYamlResponse = string;
export type GetHealthStatusData = {
    /**
     * Force a fresh check, bypassing the cache
     */
    force?: boolean;
};
export type GetHealthStatusResponse = HealthStatusResponse;
export type GetHealthDetailedResponse = DetailedHealthResponse;
export type QueryDocumentationData = {
    /**
     * query to send to the AI documentation assistant
     */
    requestBody: {
        /**
         * The documentation query to send to the AI assistant
         */
        query: string;
    };
};
export type QueryDocumentationResponse = {
    [key: string]: unknown;
};
export type GetAuditLogData = {
    id: number;
    workspace: string;
};
export type GetAuditLogResponse = AuditLog;
export type ListAuditLogsData = {
    /**
     * filter on type of operation
     */
    actionKind?: 'Create' | 'Update' | 'Delete' | 'Execute';
    /**
     * filter on created after (exclusive) timestamp
     */
    after?: string;
    /**
     * get audit logs for all workspaces
     */
    allWorkspaces?: boolean;
    /**
     * filter on started before (inclusive) timestamp
     */
    before?: string;
    /**
     * comma separated list of operations to exclude
     */
    excludeOperations?: string;
    /**
     * filter on exact or prefix name of operation
     */
    operation?: string;
    /**
     * comma separated list of exact operations to include
     */
    operations?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * filter on exact or prefix name of resource
     */
    resource?: string;
    /**
     * filter on exact username of user
     */
    username?: string;
    workspace: string;
};
export type ListAuditLogsResponse = Array<AuditLog>;
export type LoginData = {
    /**
     * credentials
     */
    requestBody: Login;
};
export type LoginResponse = string;
export type LogoutResponse = string;
export type IsSmtpConfiguredResponse = boolean;
export type IsPasswordLoginDisabledResponse = boolean;
export type RequestPasswordResetData = {
    /**
     * email to send password reset link to
     */
    requestBody: {
        email: string;
    };
};
export type RequestPasswordResetResponse = PasswordResetResponse;
export type ResetPasswordData = {
    /**
     * token and new password
     */
    requestBody: {
        token: string;
        new_password: string;
    };
};
export type ResetPasswordResponse = PasswordResetResponse;
export type GetUserData = {
    username: string;
    workspace: string;
};
export type GetUserResponse = User;
export type UpdateUserData = {
    /**
     * new user
     */
    requestBody: EditWorkspaceUser;
    username: string;
    workspace: string;
};
export type UpdateUserResponse = string;
export type IsOwnerOfPathData = {
    path: string;
    workspace: string;
};
export type IsOwnerOfPathResponse = boolean;
export type SetPasswordData = {
    /**
     * set password
     */
    requestBody: {
        password: string;
        /**
         * Optional. When provided, verified against the caller's current password before the rotation is applied.
         */
        current_password?: string;
    };
};
export type SetPasswordResponse = string;
export type SetPasswordForUserData = {
    /**
     * set password
     */
    requestBody: {
        password: string;
    };
    user: string;
};
export type SetPasswordForUserResponse = string;
export type SetLoginTypeForUserData = {
    /**
     * set login type
     */
    requestBody: {
        login_type: string;
    };
    user: string;
};
export type SetLoginTypeForUserResponse = string;
export type CreateUserGloballyData = {
    /**
     * user info
     */
    requestBody: {
        email: string;
        password: string;
        super_admin: boolean;
        name?: string;
        company?: string;
        /**
         * Skip sending email notifications to the user
         */
        skip_email?: boolean;
    };
};
export type CreateUserGloballyResponse = string;
export type GlobalUserUpdateData = {
    email: string;
    /**
     * new user info
     */
    requestBody: {
        is_super_admin?: boolean;
        is_devops?: boolean;
        name?: string;
        disabled?: boolean;
    };
};
export type GlobalUserUpdateResponse = string;
export type GlobalUsernameInfoData = {
    email: string;
};
export type GlobalUsernameInfoResponse = {
    username: string;
    workspace_usernames: Array<{
        workspace_id: string;
        username: string;
    }>;
};
export type GlobalUserRenameData = {
    email: string;
    /**
     * new username
     */
    requestBody: {
        new_username: string;
    };
};
export type GlobalUserRenameResponse = string;
export type GlobalUserDeleteData = {
    email: string;
};
export type GlobalUserDeleteResponse = string;
export type GlobalUsersOverwriteData = {
    /**
     * List of users
     */
    requestBody: Array<ExportedUser>;
};
export type GlobalUsersOverwriteResponse = string;
export type GlobalUsersExportResponse = Array<ExportedUser>;
export type ListExtJwtTokensData = {
    /**
     * only tokens used in the last 30 days
     */
    activeOnly?: boolean;
    page?: number;
    perPage?: number;
};
export type ListExtJwtTokensResponse = Array<ExternalJwtToken>;
export type SubmitOnboardingDataData = {
    requestBody: {
        touch_point?: string;
        use_case?: string;
    };
};
export type SubmitOnboardingDataResponse = string;
export type DeleteUserData = {
    username: string;
    workspace: string;
};
export type DeleteUserResponse = string;
export type OffboardPreviewData = {
    username: string;
    workspace: string;
};
export type OffboardPreviewResponse = OffboardPreview;
export type OffboardWorkspaceUserData = {
    requestBody: OffboardRequest;
    username: string;
    workspace: string;
};
export type OffboardWorkspaceUserResponse = OffboardResponse;
export type GlobalOffboardPreviewData = {
    email: string;
};
export type GlobalOffboardPreviewResponse = GlobalOffboardPreview;
export type OffboardGlobalUserData = {
    email: string;
    requestBody: GlobalOffboardRequest;
};
export type OffboardGlobalUserResponse = OffboardResponse;
export type ConvertUserToGroupData = {
    username: string;
    workspace: string;
};
export type ConvertUserToGroupResponse = string;
export type GetCurrentEmailResponse = string;
export type RefreshUserTokenData = {
    ifExpiringInLessThanS?: number;
};
export type RefreshUserTokenResponse = string;
export type GetTutorialProgressResponse = {
    progress?: number;
    skipped_all?: boolean;
};
export type UpdateTutorialProgressData = {
    /**
     * progress update
     */
    requestBody: {
        progress?: number;
        skipped_all?: boolean;
    };
};
export type UpdateTutorialProgressResponse = string;
export type LeaveInstanceResponse = string;
export type GetUsageResponse = number;
export type GetUserSeatsResponse = {
    developers: number;
    operators: number;
    developer_seats: number;
    operator_seats: number;
    total_users: number;
    users_limit: number;
};
export type GetRunnableResponse = {
    workspace: string;
    endpoint_async: string;
    endpoint_sync: string;
    summary: string;
    description?: string;
    kind: string;
};
export type GlobalWhoamiResponse = GlobalUserInfo;
export type ListWorkspaceInvitesResponse = Array<WorkspaceInvite>;
export type WhoamiData = {
    workspace: string;
};
export type WhoamiResponse = User;
export type AcceptInviteData = {
    /**
     * accept invite
     */
    requestBody: {
        workspace_id: string;
        username?: string;
    };
};
export type AcceptInviteResponse = string;
export type DeclineInviteData = {
    /**
     * decline invite
     */
    requestBody: {
        workspace_id: string;
    };
};
export type DeclineInviteResponse = string;
export type ImpersonateServiceAccountData = {
    requestBody: {
        username: string;
    };
    workspace: string;
};
export type ImpersonateServiceAccountResponse = string;
export type ExitImpersonationData = {
    requestBody: {
        token: string;
    };
    workspace: string;
};
export type ExitImpersonationResponse = string;
export type WhoisData = {
    username: string;
    workspace: string;
};
export type WhoisResponse = User;
export type ExistsEmailData = {
    email: string;
};
export type ExistsEmailResponse = boolean;
export type ListUsersAsSuperAdminData = {
    /**
     * filter only active users
     */
    activeOnly?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
};
export type ListUsersAsSuperAdminResponse = Array<GlobalUserInfo>;
export type ListUsersData = {
    workspace: string;
};
export type ListUsersResponse = Array<User>;
export type ListUsersUsageData = {
    workspace: string;
};
export type ListUsersUsageResponse = Array<UserUsage>;
export type ListUsernamesData = {
    workspace: string;
};
export type ListUsernamesResponse = Array<(string)>;
export type UsernameToEmailData = {
    username: string;
    workspace: string;
};
export type UsernameToEmailResponse = string;
export type CreateTokenData = {
    /**
     * new token
     */
    requestBody: NewToken;
};
export type CreateTokenResponse = string;
export type CreateTokenImpersonateData = {
    /**
     * new token
     */
    requestBody: NewTokenImpersonate;
};
export type CreateTokenImpersonateResponse = string;
export type DeleteTokenData = {
    tokenPrefix: string;
};
export type DeleteTokenResponse = string;
export type UpdateTokenScopesData = {
    /**
     * new scopes (null or omitted = full access)
     */
    requestBody: {
        scopes?: Array<(string)> | null;
    };
    tokenPrefix: string;
};
export type UpdateTokenScopesResponse = string;
export type ListTokensData = {
    excludeEphemeral?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
};
export type ListTokensResponse = Array<TruncatedToken>;
export type LoginWithOauthData = {
    clientName: string;
    /**
     * Partially filled script
     */
    requestBody: {
        code?: string;
        state?: string;
    };
};
export type LoginWithOauthResponse = string;
export type GetGlobalConnectedRepositoriesData = {
    /**
     * Page number for pagination (default 1)
     */
    page?: number;
};
export type GetGlobalConnectedRepositoriesResponse = GithubInstallations;
export type InstallFromWorkspaceData = {
    requestBody: {
        /**
         * The ID of the workspace containing the installation to copy
         */
        source_workspace_id: string;
        /**
         * The ID of the GitHub installation to copy
         */
        installation_id: number;
    };
    workspace: string;
};
export type InstallFromWorkspaceResponse = unknown;
export type DeleteFromWorkspaceData = {
    /**
     * The ID of the GitHub installation to delete
     */
    installationId: number;
    workspace: string;
};
export type DeleteFromWorkspaceResponse = unknown;
export type ExportInstallationData = {
    installationId: number;
    workspace: string;
};
export type ExportInstallationResponse = {
    jwt_token?: string;
};
export type ImportInstallationData = {
    requestBody: {
        jwt_token: string;
    };
    workspace: string;
};
export type ImportInstallationResponse = unknown;
export type GhesInstallationCallbackData = {
    requestBody: {
        /**
         * The GitHub App installation ID from GHES
         */
        installation_id: number;
    };
    workspace: string;
};
export type GhesInstallationCallbackResponse = unknown;
export type GetGhesConfigResponse = {
    base_url: string;
    app_slug: string;
    client_id: string;
    app_owner?: string | null;
};
export type ListWorkspacesResponse = Array<Workspace>;
export type IsDomainAllowedResponse = boolean;
export type ListUserWorkspacesResponse = UserWorkspaceList;
export type GetWorkspaceAsSuperAdminData = {
    workspace: string;
};
export type GetWorkspaceAsSuperAdminResponse = Workspace;
export type ListWorkspacesAsSuperAdminData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
};
export type ListWorkspacesAsSuperAdminResponse = Array<Workspace>;
export type CreateWorkspaceData = {
    /**
     * new token
     */
    requestBody: CreateWorkspace;
};
export type CreateWorkspaceResponse = string;
export type CreateWorkspaceForkGitBranchData = {
    /**
     * new forked workspace
     */
    requestBody: CreateWorkspaceFork;
    workspace: string;
};
export type CreateWorkspaceForkGitBranchResponse = Array<(string)>;
export type CreateWorkspaceForkData = {
    /**
     * new forked workspace
     */
    requestBody: CreateWorkspaceFork;
    workspace: string;
};
export type CreateWorkspaceForkResponse = string;
export type ExistsWorkspaceData = {
    /**
     * id of workspace
     */
    requestBody: {
        id: string;
    };
};
export type ExistsWorkspaceResponse = boolean;
export type ExistsUsernameData = {
    requestBody: {
        id: string;
        username: string;
    };
};
export type ExistsUsernameResponse = boolean;
export type GetGithubAppTokenData = {
    /**
     * jwt job token
     */
    requestBody: {
        job_token: string;
    };
    workspace: string;
};
export type GetGithubAppTokenResponse = {
    token: string;
};
export type InviteUserData = {
    /**
     * WorkspaceInvite
     */
    requestBody: {
        email: string;
        is_admin: boolean;
        operator: boolean;
        parent_workspace_id?: string | null;
    };
    workspace: string;
};
export type InviteUserResponse = string;
export type AddUserData = {
    /**
     * WorkspaceInvite
     */
    requestBody: {
        email: string;
        is_admin: boolean;
        username?: string;
        operator: boolean;
    };
    workspace: string;
};
export type AddUserResponse = string;
export type CreateServiceAccountData = {
    requestBody: {
        username: string;
    };
    workspace: string;
};
export type CreateServiceAccountResponse = string;
export type DeleteInviteData = {
    /**
     * WorkspaceInvite
     */
    requestBody: {
        email: string;
        is_admin: boolean;
        operator: boolean;
    };
    workspace: string;
};
export type DeleteInviteResponse = string;
export type ArchiveWorkspaceData = {
    workspace: string;
};
export type ArchiveWorkspaceResponse = string;
export type UnarchiveWorkspaceData = {
    workspace: string;
};
export type UnarchiveWorkspaceResponse = string;
export type DeleteWorkspaceData = {
    onlyDeleteForks?: boolean;
    workspace: string;
};
export type DeleteWorkspaceResponse = string;
export type LeaveWorkspaceData = {
    workspace: string;
};
export type LeaveWorkspaceResponse = string;
export type GetWorkspaceNameData = {
    workspace: string;
};
export type GetWorkspaceNameResponse = string;
export type ChangeWorkspaceNameData = {
    requestBody?: {
        new_name?: string;
    };
    workspace: string;
};
export type ChangeWorkspaceNameResponse = string;
export type ChangeWorkspaceIdData = {
    requestBody?: {
        new_id?: string;
        new_name?: string;
    };
    workspace: string;
};
export type ChangeWorkspaceIdResponse = string;
export type ChangeWorkspaceColorData = {
    requestBody?: {
        color?: string;
    };
    workspace: string;
};
export type ChangeWorkspaceColorResponse = string;
export type UpdateOperatorSettingsData = {
    requestBody: OperatorSettings;
    workspace: string;
};
export type UpdateOperatorSettingsResponse = string;
export type CompareWorkspacesData = {
    /**
     * The ID of the workspace to compare with
     */
    targetWorkspaceId: string;
    workspace: string;
};
export type CompareWorkspacesResponse = WorkspaceComparison;
export type ResetDiffTallyData = {
    /**
     * The ID of the workspace to compare with
     */
    forkWorkspaceId: string;
    workspace: string;
};
export type ResetDiffTallyResponse = unknown;
export type ListPendingInvitesData = {
    workspace: string;
};
export type ListPendingInvitesResponse = Array<WorkspaceInvite>;
export type GetPublicSettingsData = {
    workspace: string;
};
export type GetPublicSettingsResponse = {
    workspace_id: string;
    slack_name?: string;
    slack_team_id?: string;
    teams_team_id?: string;
    teams_team_name?: string;
    teams_team_guid?: string;
    large_file_storage?: LargeFileStorage;
    datatable?: DataTableSettings;
    deploy_ui?: WorkspaceDeployUISettings;
    mute_critical_alerts?: boolean;
};
export type GetSettingsData = {
    workspace: string;
};
export type GetSettingsResponse = {
    workspace_id?: string;
    slack_name?: string;
    slack_team_id?: string;
    slack_command_script?: string;
    slack_oauth_client_id?: string;
    slack_oauth_client_secret?: string;
    teams_team_id?: string;
    teams_command_script?: string;
    teams_team_name?: string;
    teams_team_guid?: string;
    auto_invite?: AutoInviteConfig;
    plan?: string;
    customer_id?: string;
    webhook?: string;
    deploy_to?: string;
    ai_config?: AIConfig;
    error_handler?: ErrorHandlerConfig;
    success_handler?: SuccessHandlerConfig;
    large_file_storage?: LargeFileStorage;
    ducklake?: DucklakeSettings;
    datatable?: DataTableSettings;
    git_sync?: WorkspaceGitSyncSettings;
    deploy_ui?: WorkspaceDeployUISettings;
    default_app?: string;
    default_scripts?: WorkspaceDefaultScripts;
    mute_critical_alerts?: boolean;
    color?: string;
    operator_settings?: OperatorSettings;
    /**
     * Rate limit for public app executions per minute per server. NULL or 0 means disabled.
     */
    public_app_execution_limit_per_minute?: number;
};
export type GetDeployToData = {
    workspace: string;
};
export type GetDeployToResponse = {
    deploy_to?: string;
};
export type GetIsPremiumData = {
    workspace: string;
};
export type GetIsPremiumResponse = boolean;
export type TarballWorkspaceData = {
    /**
     * "zip" or "tar" (default)
     */
    archiveType?: 'zip' | 'tar';
    /**
     * "bun" or "deno" -- selects the .ts extension used for Bun-language scripts
     */
    defaultTs?: 'bun' | 'deno';
    /**
     * Opt-in, default false, added in #729. `dmn_decision` rows are
     * workspace source code, same as flows -- but unlike flows this
     * defaults off, matching `include_schedules`/`include_triggers`:
     * the CLI (#822) has sent this parameter since before the backend
     * read it, and independently gates its own local sync file map on
     * a matching `--include-dmn` flag. Both gates exist because a path
     * present locally but absent from the tarball is indistinguishable
     * from "deleted upstream" to `sync pull`, and an opt-out default
     * would have archived every locally-pushed decision on the first
     * pull after this endpoint started supporting DMN at all.
     *
     */
    includeDmn?: boolean;
    includeGroups?: boolean;
    includeKey?: boolean;
    includeSchedules?: boolean;
    includeSettings?: boolean;
    includeTriggers?: boolean;
    includeUsers?: boolean;
    includeWorkspaceDependencies?: boolean;
    plainSecret?: boolean;
    /**
     * "v1" (legacy flat format, default) or "v2" (grouped format)
     */
    settingsVersion?: 'v1' | 'v2';
    skipResources?: boolean;
    skipResourceTypes?: boolean;
    skipSecrets?: boolean;
    skipVariables?: boolean;
    workspace: string;
};
export type TarballWorkspaceResponse = (Blob | File);
export type GetThresholdAlertData = {
    workspace: string;
};
export type GetThresholdAlertResponse = {
    threshold_alert_amount?: number;
    last_alert_sent?: string;
};
export type SetThresholdAlertData = {
    /**
     * threshold alert info
     */
    requestBody: {
        threshold_alert_amount?: number;
    };
    workspace: string;
};
export type SetThresholdAlertResponse = string;
export type RebuildDependencyMapData = {
    workspace: string;
};
export type RebuildDependencyMapResponse = string;
export type GetDependentsData = {
    /**
     * The imported path to get dependents for
     */
    importedPath: string;
    workspace: string;
};
export type GetDependentsResponse = Array<DependencyDependent>;
export type GetImportsData = {
    /**
     * The script path to get imports for
     */
    importerPath: string;
    workspace: string;
};
export type GetImportsResponse = Array<(string)>;
export type GetDependentsAmountsData = {
    /**
     * List of imported paths to get dependents counts for
     */
    requestBody: Array<(string)>;
    workspace: string;
};
export type GetDependentsAmountsResponse = Array<DependentsAmount>;
export type GetDependencyMapData = {
    workspace: string;
};
export type GetDependencyMapResponse = Array<DependencyMap>;
export type EditSlackCommandData = {
    /**
     * WorkspaceInvite
     */
    requestBody: {
        slack_command_script?: string;
    };
    workspace: string;
};
export type EditSlackCommandResponse = string;
export type GetWorkspaceSlackOauthConfigData = {
    workspace: string;
};
export type GetWorkspaceSlackOauthConfigResponse = {
    slack_oauth_client_id?: string | null;
    /**
     * Masked with *** if set
     */
    slack_oauth_client_secret?: string | null;
};
export type SetWorkspaceSlackOauthConfigData = {
    /**
     * Slack OAuth Configuration
     */
    requestBody: {
        slack_oauth_client_id: string;
        slack_oauth_client_secret: string;
    };
    workspace: string;
};
export type SetWorkspaceSlackOauthConfigResponse = string;
export type DeleteWorkspaceSlackOauthConfigData = {
    workspace: string;
};
export type DeleteWorkspaceSlackOauthConfigResponse = string;
export type EditTeamsCommandData = {
    /**
     * script/flow to run on the /orvanta Teams command. Omit or null to clear it.
     */
    requestBody: {
        teams_command_script?: string;
    };
    workspace: string;
};
export type EditTeamsCommandResponse = string;
export type ListAvailableTeamsIdsData = {
    /**
     * Pagination cursor URL from previous response. Pass this to fetch the next page of results.
     */
    nextLink?: string;
    /**
     * Search teams by name. If omitted, returns first page of all teams.
     */
    search?: string;
    workspace: string;
};
export type ListAvailableTeamsIdsResponse = {
    teams?: Array<{
        team_name?: string;
        team_id?: string;
    }>;
    /**
     * Total number of teams across all pages
     */
    total_count?: number;
    /**
     * Number of teams per page (configurable via TEAMS_PER_PAGE env var)
     */
    per_page?: number;
    /**
     * URL to fetch next page of results. Null if no more pages.
     */
    next_link?: string | null;
};
export type ListAvailableTeamsChannelsData = {
    /**
     * Microsoft Teams team ID
     */
    teamId: string;
    workspace: string;
};
export type ListAvailableTeamsChannelsResponse = {
    channels?: Array<{
        channel_name?: string;
        channel_id?: string;
    }>;
    total_count?: number;
};
export type ConnectTeamsData = {
    /**
     * connect teams
     */
    requestBody: {
        team_id?: string;
        team_name?: string;
    };
    workspace: string;
};
export type ConnectTeamsResponse = string;
export type ConnectSlackData = {
    /**
     * connect slack with a pre-minted bot token
     */
    requestBody: {
        /**
         * xoxb-... bot token obtained at api.slack.com/apps
         */
        bot_token: string;
        team_id: string;
        team_name: string;
    };
    workspace: string;
};
export type ConnectSlackResponse = unknown;
export type RunSlackMessageTestJobData = {
    /**
     * path to hub script to run and its corresponding args
     */
    requestBody: {
        hub_script_path?: string;
        channel?: string;
        test_msg?: string;
    };
    workspace: string;
};
export type RunSlackMessageTestJobResponse = {
    job_uuid?: string;
};
export type RunTeamsMessageTestJobData = {
    /**
     * path to hub script to run and its corresponding args
     */
    requestBody: {
        hub_script_path?: string;
        channel?: string;
        test_msg?: string;
    };
    workspace: string;
};
export type RunTeamsMessageTestJobResponse = {
    job_uuid?: string;
};
export type EditDeployToData = {
    requestBody: {
        deploy_to?: string;
    };
    workspace: string;
};
export type EditDeployToResponse = string;
export type EditAutoInviteData = {
    /**
     * WorkspaceInvite
     */
    requestBody: {
        operator?: boolean;
        invite_all?: boolean;
        auto_add?: boolean;
        /**
         * Explicit auto-invite domain to use instead of deriving one from the caller's own email. A workspace admin may only set their own domain; setting a different domain requires the caller to be a superadmin. Case-insensitive (stored lowercased); non-ASCII is rejected. Omitting this field leaves the currently stored domain unchanged; sending an explicit empty string resets it to the caller's own domain.
         *
         */
        domain?: string;
    };
    workspace: string;
};
export type EditAutoInviteResponse = string;
export type EditInstanceGroupsData = {
    /**
     * Instance Groups Configuration
     */
    requestBody: {
        groups?: Array<(string)>;
        roles?: {
            [key: string]: (string);
        };
    };
    workspace: string;
};
export type EditInstanceGroupsResponse = string;
export type EditWebhookData = {
    /**
     * WorkspaceWebhook
     */
    requestBody: {
        webhook?: string;
    };
    workspace: string;
};
export type EditWebhookResponse = string;
export type EditCopilotConfigData = {
    /**
     * WorkspaceCopilotConfig
     */
    requestBody: AIConfig;
    workspace: string;
};
export type EditCopilotConfigResponse = {
    effective_ai_config: AIConfig;
    has_instance_ai_config: boolean;
    uses_instance_ai_config: boolean;
    instance_ai_summary?: InstanceAISummary;
};
export type GetCopilotSettingsStateData = {
    workspace: string;
};
export type GetCopilotSettingsStateResponse = {
    has_instance_ai_config: boolean;
    uses_instance_ai_config: boolean;
    instance_ai_summary?: InstanceAISummary;
};
export type GetCopilotInfoData = {
    workspace: string;
};
export type GetCopilotInfoResponse = AIConfig;
export type EditErrorHandlerData = {
    /**
     * WorkspaceErrorHandler
     */
    requestBody: EditErrorHandler;
    workspace: string;
};
export type EditErrorHandlerResponse = string;
export type EditSuccessHandlerData = {
    /**
     * WorkspaceSuccessHandler
     */
    requestBody: EditSuccessHandler;
    workspace: string;
};
export type EditSuccessHandlerResponse = string;
export type EditLargeFileStorageConfigData = {
    /**
     * LargeFileStorage info
     */
    requestBody: {
        large_file_storage?: LargeFileStorage;
    };
    workspace: string;
};
export type EditLargeFileStorageConfigResponse = unknown;
export type ListDucklakesData = {
    workspace: string;
};
export type ListDucklakesResponse = Array<(string)>;
export type ListDataTablesData = {
    workspace: string;
};
export type ListDataTablesResponse = Array<{
    name: string;
    resource_type: 'postgres' | 'instance';
    resource_path: string;
}>;
export type ListDataTableSchemasData = {
    workspace: string;
};
export type ListDataTableSchemasResponse = Array<DataTableSchema>;
export type ListDataTableTablesData = {
    workspace: string;
};
export type ListDataTableTablesResponse = Array<DataTableTables>;
export type GetDataTableTableSchemaData = {
    datatableName: string;
    schemaName: string;
    tableName: string;
    workspace: string;
};
export type GetDataTableTableSchemaResponse = DataTableTableSchema;
export type EditDucklakeConfigData = {
    /**
     * Ducklake settings
     */
    requestBody: {
        settings: DucklakeSettings;
    };
    workspace: string;
};
export type EditDucklakeConfigResponse = unknown;
export type EditDataTableConfigData = {
    /**
     * DataTable settings
     */
    requestBody: {
        settings: DataTableSettings;
    };
    workspace: string;
};
export type EditDataTableConfigResponse = unknown;
export type CreatePgDatabaseData = {
    /**
     * Create pg database request
     */
    requestBody: {
        /**
         * Datatable source to determine connection info: 'datatable://name' or '$res:path'
         */
        source: string;
        /**
         * Name for the new database
         */
        target_dbname: string;
    };
    workspace: string;
};
export type CreatePgDatabaseResponse = string;
export type DropForkedDatatableDatabasesData = {
    requestBody: {
        datatable_names: Array<(string)>;
    };
    workspace: string;
};
export type DropForkedDatatableDatabasesResponse = Array<(string)>;
export type ImportPgDatabaseData = {
    /**
     * Import pg database request
     */
    requestBody: {
        /**
         * Source database: 'datatable://name' or '$res:path'
         */
        source: string;
        /**
         * Target database: 'datatable://name' or '$res:path'
         */
        target: string;
        /**
         * Override the target database name
         */
        target_dbname_override?: string;
        fork_behavior: 'schema_only' | 'schema_and_data' | 'keep_original';
    };
    workspace: string;
};
export type ImportPgDatabaseResponse = string;
export type ExportPgSchemaData = {
    /**
     * Export pg schema request
     */
    requestBody: {
        /**
         * Source database: 'datatable://name' or '$res:path'
         */
        source: string;
    };
    workspace: string;
};
export type ExportPgSchemaResponse = string;
export type GetDatatableFullSchemaData = {
    requestBody: {
        /**
         * Source datatable, e.g. 'datatable://main'
         */
        source: string;
    };
    workspace: string;
};
export type GetDatatableFullSchemaResponse = {
    [key: string]: {
        [key: string]: {
            name: string;
            columns: Array<{
                name: string;
                datatype: string;
                primary_key?: boolean;
                default_value?: string;
                nullable?: boolean;
            }>;
            foreign_keys: Array<{
                target_table?: string;
                columns: Array<{
                    source_column?: string;
                    target_column?: string;
                }>;
                on_delete: string;
                on_update: string;
                fk_constraint_name?: string;
            }>;
            pk_constraint_name?: string;
        };
    };
};
export type GetGitSyncEnabledData = {
    workspace: string;
};
export type GetGitSyncEnabledResponse = {
    enabled?: boolean;
    reason?: string | null;
    max_repos?: number | null;
    user_count?: number | null;
    max_users?: number | null;
};
export type EditWorkspaceGitSyncConfigData = {
    /**
     * Workspace Git sync settings
     */
    requestBody: {
        git_sync_settings?: WorkspaceGitSyncSettings;
    };
    workspace: string;
};
export type EditWorkspaceGitSyncConfigResponse = unknown;
export type EditGitSyncRepositoryData = {
    /**
     * Git sync repository settings to add or update
     */
    requestBody: {
        /**
         * The resource path of the git repository to update
         */
        git_repo_resource_path: string;
        repository: GitRepositorySettings;
    };
    workspace: string;
};
export type EditGitSyncRepositoryResponse = unknown;
export type DeleteGitSyncRepositoryData = {
    /**
     * Git sync repository to delete
     */
    requestBody: {
        /**
         * The resource path of the git repository to delete
         */
        git_repo_resource_path: string;
    };
    workspace: string;
};
export type DeleteGitSyncRepositoryResponse = unknown;
export type EditWorkspaceDeployUiSettingsData = {
    /**
     * Workspace deploy UI settings
     */
    requestBody: {
        deploy_ui_settings?: WorkspaceDeployUISettings;
    };
    workspace: string;
};
export type EditWorkspaceDeployUiSettingsResponse = unknown;
export type EditWorkspaceDefaultAppData = {
    /**
     * Workspace default app
     */
    requestBody: {
        default_app_path?: string;
    };
    workspace: string;
};
export type EditWorkspaceDefaultAppResponse = string;
export type EditDefaultScriptsData = {
    /**
     * Workspace default app
     */
    requestBody?: WorkspaceDefaultScripts;
    workspace: string;
};
export type EditDefaultScriptsResponse = string;
export type GetDefaultScriptsData = {
    workspace: string;
};
export type GetDefaultScriptsResponse = WorkspaceDefaultScripts;
export type SetEnvironmentVariableData = {
    /**
     * Workspace default app
     */
    requestBody: {
        name: string;
        value?: string;
    };
    workspace: string;
};
export type SetEnvironmentVariableResponse = string;
export type GetWorkspaceEncryptionKeyData = {
    workspace: string;
};
export type GetWorkspaceEncryptionKeyResponse = {
    key: string;
};
export type SetWorkspaceEncryptionKeyData = {
    /**
     * New encryption key
     */
    requestBody: {
        new_key: string;
        skip_reencrypt?: boolean;
    };
    workspace: string;
};
export type SetWorkspaceEncryptionKeyResponse = string;
export type GetWorkspaceDefaultAppData = {
    workspace: string;
};
export type GetWorkspaceDefaultAppResponse = {
    default_app_path?: string;
    default_app_raw?: boolean;
};
export type GetWorkspaceUsageData = {
    workspace: string;
};
export type GetWorkspaceUsageResponse = number;
export type GetUsedTriggersData = {
    workspace: string;
};
export type GetUsedTriggersResponse = {
    http_routes_used: boolean;
    websocket_used: boolean;
    kafka_used: boolean;
    nats_used: boolean;
    postgres_used: boolean;
    mqtt_used: boolean;
    gcp_used: boolean;
    azure_used: boolean;
    sqs_used: boolean;
    email_used: boolean;
    nextcloud_used: boolean;
    google_used: boolean;
    github_used: boolean;
};
export type ListProtectionRulesData = {
    workspace: string;
};
export type ListProtectionRulesResponse = Array<ProtectionRuleset>;
export type CreateProtectionRuleData = {
    /**
     * New protection rule configuration
     */
    requestBody: {
        /**
         * Unique name for the protection rule
         */
        name: string;
        rules: ProtectionRules;
        bypass_groups: RuleBypasserGroups;
        bypass_users: RuleBypasserUsers;
    };
    workspace: string;
};
export type CreateProtectionRuleResponse = string;
export type UpdateProtectionRuleData = {
    /**
     * Updated protection rule configuration
     */
    requestBody: {
        rules: ProtectionRules;
        bypass_groups: RuleBypasserGroups;
        bypass_users: RuleBypasserUsers;
    };
    /**
     * Name of the protection rule to update
     */
    ruleName: string;
    workspace: string;
};
export type UpdateProtectionRuleResponse = string;
export type DeleteProtectionRuleData = {
    /**
     * Name of the protection rule to delete
     */
    ruleName: string;
    workspace: string;
};
export type DeleteProtectionRuleResponse = string;
export type ListDeploymentRequestEligibleDeployersData = {
    workspace: string;
};
export type ListDeploymentRequestEligibleDeployersResponse = Array<DeploymentRequestEligibleDeployer>;
export type GetOpenDeploymentRequestData = {
    workspace: string;
};
export type GetOpenDeploymentRequestResponse = (DeploymentRequest) | null;
export type CreateDeploymentRequestData = {
    requestBody: {
        /**
         * Usernames in the parent workspace. Must be admin or wm_deployers.
         */
        assignees: Array<(string)>;
    };
    workspace: string;
};
export type CreateDeploymentRequestResponse = DeploymentRequest;
export type CancelDeploymentRequestData = {
    id: number;
    workspace: string;
};
export type CancelDeploymentRequestResponse = string;
export type CloseDeploymentRequestMergedData = {
    id: number;
    workspace: string;
};
export type CloseDeploymentRequestMergedResponse = string;
export type CreateDeploymentRequestCommentData = {
    id: number;
    requestBody: {
        body: string;
        parent_id?: number | null;
        anchor_kind?: string | null;
        anchor_path?: string | null;
    };
    workspace: string;
};
export type CreateDeploymentRequestCommentResponse = DeploymentRequestComment;
export type LogAiChatData = {
    requestBody: {
        session_id: string;
        provider: string;
        model: string;
        mode: string;
    };
    workspace: string;
};
export type LogAiChatResponse = void;
export type GetCloudQuotasData = {
    workspace: string;
};
export type GetCloudQuotasResponse = {
    scripts: QuotaInfo;
    flows: QuotaInfo;
    apps: QuotaInfo;
    variables: QuotaInfo;
    resources: QuotaInfo;
};
export type PruneVersionsData = {
    requestBody: {
        resource_type: 'scripts' | 'flows' | 'apps';
    };
    workspace: string;
};
export type PruneVersionsResponse = {
    pruned: number;
};
export type ListWsSpecificData = {
    workspace: string;
};
export type ListWsSpecificResponse = Array<{
    item_kind: string;
    path: string;
}>;
export type ListWsSpecificVersionsData = {
    kind: 'resource' | 'variable';
    path: string;
    workspace: string;
};
export type ListWsSpecificVersionsResponse = Array<(string)>;
export type GetSharedUiData = {
    workspace: string;
};
export type GetSharedUiResponse = {
    files: {
        [key: string]: (string);
    };
    version: number;
    edited_at: string;
    edited_by: string;
};
export type ListSharedUiData = {
    workspace: string;
};
export type ListSharedUiResponse = {
    paths: Array<(string)>;
    sizes: {
        [key: string]: (number);
    };
    version: number;
    edited_at: string;
    edited_by: string;
};
export type GetSharedUiVersionData = {
    workspace: string;
};
export type GetSharedUiVersionResponse = {
    version: number;
};
export type UpdateSharedUiData = {
    requestBody: {
        files: {
            [key: string]: (string);
        };
    };
    workspace: string;
};
export type UpdateSharedUiResponse = string;
export type RefreshCustomInstanceUserPwdResponse = {
    [key: string]: unknown;
};
export type ListCustomInstanceDbsResponse = {
    [key: string]: CustomInstanceDb;
};
export type SetupCustomInstanceDbData = {
    /**
     * The name of the database to create
     */
    name: string;
    requestBody: {
        tag?: CustomInstanceDbTag;
    };
};
export type SetupCustomInstanceDbResponse = CustomInstanceDb;
export type DropCustomInstanceDbData = {
    /**
     * The name of the database to drop
     */
    name: string;
};
export type DropCustomInstanceDbResponse = string;
export type GetGlobalData = {
    key: string;
};
export type GetGlobalResponse = unknown;
export type SetGlobalData = {
    key: string;
    /**
     * value set
     */
    requestBody: {
        value?: unknown;
    };
};
export type SetGlobalResponse = string;
export type GetRuffConfigResponse = string;
export type GetLocalResponse = unknown;
export type TestSmtpData = {
    /**
     * test smtp payload
     */
    requestBody: {
        to: string;
        smtp: {
            host: string;
            username: string;
            password: string;
            port: number;
            from: string;
            tls_implicit: boolean;
            disable_tls: boolean;
        };
    };
};
export type TestSmtpResponse = string;
export type TestCriticalChannelsData = {
    /**
     * test critical channel payload
     */
    requestBody: Array<{
        email?: string;
        slack_channel?: string;
    }>;
};
export type TestCriticalChannelsResponse = string;
export type GetCriticalAlertsData = {
    acknowledged?: boolean | null;
    page?: number;
    pageSize?: number;
};
export type GetCriticalAlertsResponse = {
    alerts?: Array<CriticalAlert>;
    /**
     * Total number of rows matching the query.
     */
    total_rows?: number;
    /**
     * Total number of pages based on the page size.
     */
    total_pages?: number;
};
export type AcknowledgeCriticalAlertData = {
    /**
     * The ID of the critical alert to acknowledge
     */
    id: number;
};
export type AcknowledgeCriticalAlertResponse = string;
export type AcknowledgeAllCriticalAlertsResponse = string;
export type TestLicenseKeyData = {
    /**
     * test license key
     */
    requestBody: {
        license_key: string;
    };
};
export type TestLicenseKeyResponse = string;
export type RevalidateLicenseResponse = {
    /**
     * licence validated successfully
     */
    ok: boolean;
    tier?: string;
    edition?: string;
    expires_at?: string | null;
    /**
     * instance is licence-degraded to read-only
     */
    read_only: boolean;
    first_failure_at?: string | null;
    /**
     * this call cleared a pre-existing failure
     */
    recovered?: boolean;
    tier_changed?: boolean;
};
export type TestObjectStorageConfigData = {
    /**
     * test object storage config
     */
    requestBody: {
        [key: string]: unknown;
    };
};
export type TestObjectStorageConfigResponse = string;
export type GetObjectStorageUsageResponse = {
    running: boolean;
    started_at: string;
    finished_at?: string | null;
    current_prefix?: string | null;
    scanned_objects: number;
    folders: Array<{
        prefix: string;
        size: number;
        partial?: boolean;
    }>;
    error?: string | null;
} | null;
export type ComputeObjectStorageUsageResponse = string;
export type RunLogCleanupResponse = string;
export type GetLogCleanupStatusResponse = {
    running: boolean;
    started_at: string;
    finished_at?: string | null;
    phase: string;
    total_service: number;
    processed_service: number;
    total_jobs: number;
    processed_jobs: number;
    s3_deleted: number;
    orphans_scanned: number;
    orphans_deleted: number;
    errors: number;
    last_error?: string | null;
} | null;
export type SendStatsResponse = string;
export type RestartWorkerGroupData = {
    /**
     * the name of the worker group to restart
     */
    workerGroup: string;
};
export type RestartWorkerGroupResponse = string;
export type RestartWorkerPoolData = {
    /**
     * the name of the worker pool to restart
     */
    workerPool: string;
};
export type RestartWorkerPoolResponse = string;
export type GetStatsResponse = {
    signature?: string;
    data?: string;
};
export type GetLatestKeyRenewalAttemptResponse = {
    result: string;
    attempted_at: string;
} | null;
export type RenewLicenseKeyData = {
    licenseKey?: string;
};
export type RenewLicenseKeyResponse = string;
export type CreateCustomerPortalSessionData = {
    licenseKey?: string;
};
export type CreateCustomerPortalSessionResponse = string;
export type TestMetadataData = {
    /**
     * test metadata
     */
    requestBody: string;
};
export type TestMetadataResponse = string;
export type GetSamlSpMetadataResponse = string;
export type GetSamlConfigResponse = SamlConfig;
export type SaveSamlConfigData = {
    /**
     * SAML configuration
     */
    requestBody: SamlConfigRequest;
};
export type SaveSamlConfigResponse = SamlConfig;
export type DeleteSamlConfigResponse = string;
export type InitiateSamlLoginData = {
    /**
     * Post-login redirect target, constrained to a same-origin relative path. Held server-side against the request ID; never sent to the IdP.
     */
    relayState?: string;
};
export type InitiateSamlLoginGetData = {
    relayState?: string;
};
export type UpdateSamlMetadataResponse = SamlConfig;
export type ListGlobalSettingsResponse = Array<GlobalSetting>;
export type GetRuntimeUsageResponse = Array<RuntimeUsageCount>;
export type GetRuntimeUsageLocationsData = {
    language: ScriptLang;
};
export type GetRuntimeUsageLocationsResponse = Array<RuntimeUsageLocation>;
export type GetInstanceConfigResponse = InstanceConfig;
export type SetInstanceConfigData = {
    /**
     * full instance configuration to apply
     */
    requestBody: InstanceConfig;
};
export type SetInstanceConfigResponse = string;
export type GetMinKeepAliveVersionResponse = {
    /**
     * minimum version for normal workers
     */
    worker: string;
    /**
     * minimum version for agent workers
     */
    agent: string;
};
export type GetJwksResponse = JwksResponse;
export type TestSecretBackendData = {
    /**
     * Vault settings to test
     */
    requestBody: VaultSettings;
};
export type TestSecretBackendResponse = string;
export type MigrateSecretsToVaultData = {
    /**
     * Vault settings for migration target
     */
    requestBody: VaultSettings;
};
export type MigrateSecretsToVaultResponse = SecretMigrationReport;
export type MigrateSecretsToDatabaseData = {
    /**
     * Vault settings for migration source
     */
    requestBody: VaultSettings;
};
export type MigrateSecretsToDatabaseResponse = SecretMigrationReport;
export type TestAzureKvBackendData = {
    /**
     * Azure Key Vault settings to test
     */
    requestBody: AzureKeyVaultSettings;
};
export type TestAzureKvBackendResponse = string;
export type MigrateSecretsToAzureKvData = {
    /**
     * Azure Key Vault settings for migration target
     */
    requestBody: AzureKeyVaultSettings;
};
export type MigrateSecretsToAzureKvResponse = SecretMigrationReport;
export type MigrateSecretsFromAzureKvData = {
    /**
     * Azure Key Vault settings for migration source
     */
    requestBody: AzureKeyVaultSettings;
};
export type MigrateSecretsFromAzureKvResponse = SecretMigrationReport;
export type TestAwsSmBackendData = {
    requestBody: AwsSecretsManagerSettings;
};
export type TestAwsSmBackendResponse = string;
export type MigrateSecretsToAwsSmData = {
    requestBody: AwsSecretsManagerSettings;
};
export type MigrateSecretsToAwsSmResponse = SecretMigrationReport;
export type MigrateSecretsFromAwsSmData = {
    requestBody: AwsSecretsManagerSettings;
};
export type MigrateSecretsFromAwsSmResponse = SecretMigrationReport;
export type GetSecondaryStorageNamesData = {
    /**
     * If true, include "_default_" in the list if primary workspace storage is set
     */
    includeDefault?: boolean;
    workspace: string;
};
export type GetSecondaryStorageNamesResponse = Array<(string)>;
export type WorkspaceGetCriticalAlertsData = {
    acknowledged?: boolean | null;
    page?: number;
    pageSize?: number;
    workspace: string;
};
export type WorkspaceGetCriticalAlertsResponse = {
    alerts?: Array<CriticalAlert>;
    /**
     * Total number of rows matching the query.
     */
    total_rows?: number;
    /**
     * Total number of pages based on the page size.
     */
    total_pages?: number;
};
export type WorkspaceAcknowledgeCriticalAlertData = {
    /**
     * The ID of the critical alert to acknowledge
     */
    id: number;
    workspace: string;
};
export type WorkspaceAcknowledgeCriticalAlertResponse = string;
export type WorkspaceAcknowledgeAllCriticalAlertsData = {
    workspace: string;
};
export type WorkspaceAcknowledgeAllCriticalAlertsResponse = string;
export type WorkspaceMuteCriticalAlertsUiData = {
    /**
     * Boolean flag to mute critical alerts.
     */
    requestBody: {
        /**
         * Whether critical alerts should be muted.
         */
        mute_critical_alerts?: boolean;
    };
    workspace: string;
};
export type WorkspaceMuteCriticalAlertsUiResponse = string;
export type SetPublicAppRateLimitData = {
    /**
     * Public app rate limit configuration
     */
    requestBody: {
        /**
         * Rate limit for public app executions per minute per server. NULL or 0 to disable.
         */
        public_app_execution_limit_per_minute?: number;
    };
    workspace: string;
};
export type SetPublicAppRateLimitResponse = string;
export type ListAvailableScopesResponse = Array<ScopeDomain>;
export type GetOidcTokenData = {
    audience: string;
    expiresIn?: number;
    workspace: string;
};
export type GetOidcTokenResponse = string;
export type CreateVariableData = {
    /**
     * whether the variable is already encrypted (default false)
     */
    alreadyEncrypted?: boolean;
    /**
     * new variable
     */
    requestBody: CreateVariable;
    workspace: string;
};
export type CreateVariableResponse = string;
export type EncryptValueData = {
    /**
     * new variable
     */
    requestBody: string;
    workspace: string;
};
export type EncryptValueResponse = string;
export type DeleteVariableData = {
    path: string;
    workspace: string;
};
export type DeleteVariableResponse = string;
export type DeleteVariablesBulkData = {
    /**
     * paths to delete
     */
    requestBody: {
        paths: Array<(string)>;
    };
    workspace: string;
};
export type DeleteVariablesBulkResponse = Array<(string)>;
export type UpdateVariableData = {
    /**
     * whether the variable is already encrypted (default false)
     */
    alreadyEncrypted?: boolean;
    path: string;
    /**
     * updated variable
     */
    requestBody: EditVariable;
    workspace: string;
};
export type UpdateVariableResponse = string;
export type GetVariableData = {
    /**
     * ask to decrypt secret if this variable is secret
     * (if not secret no effect, default: true)
     *
     */
    decryptSecret?: boolean;
    /**
     * ask to include the encrypted value if secret and decrypt secret is not true (default: false)
     *
     */
    includeEncrypted?: boolean;
    path: string;
    workspace: string;
};
export type GetVariableResponse = ListableVariable;
export type GetVariableValueData = {
    /**
     * allow getting a cached value for improved performance
     *
     */
    allowCache?: boolean;
    path: string;
    workspace: string;
};
export type GetVariableValueResponse = string;
export type ExistsVariableData = {
    path: string;
    workspace: string;
};
export type ExistsVariableResponse = boolean;
export type ListVariableData = {
    /**
     * broad search across multiple fields (case-insensitive substring match)
     */
    broadFilter?: string;
    /**
     * pattern match filter for description field (case-insensitive)
     */
    description?: string;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * exact path match filter
     */
    path?: string;
    /**
     * filter variables by path prefix
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * pattern match filter for non-secret variable values (case-insensitive)
     */
    value?: string;
    workspace: string;
};
export type ListVariableResponse = Array<ListableVariable>;
export type ListContextualVariablesData = {
    workspace: string;
};
export type ListContextualVariablesResponse = Array<ContextualVariable>;
export type ConnectSlackInitiateData = {
    workspace: string;
};
export type ConnectSlackCallbackData = {
    /**
     * code endpoint
     */
    requestBody: {
        code: string;
        state: string;
    };
    workspace: string;
};
export type ConnectSlackCallbackResponse = string;
export type ConnectSlackCallbackInstanceData = {
    /**
     * code endpoint
     */
    requestBody: {
        code: string;
        state: string;
    };
};
export type ConnectSlackCallbackInstanceResponse = string;
export type ConnectSlackInstanceData = {
    /**
     * connect slack at the instance level with a pre-minted bot token
     */
    requestBody: {
        /**
         * xoxb-... bot token obtained at api.slack.com/apps
         */
        bot_token: string;
        team_id: string;
        team_name: string;
    };
};
export type ConnectSlackInstanceResponse = unknown;
export type ConnectCallbackData = {
    clientName: string;
    /**
     * code endpoint
     */
    requestBody: {
        code: string;
        state: string;
    };
};
export type ConnectCallbackResponse = TokenResponse;
export type CreateAccountData = {
    /**
     * code endpoint
     */
    requestBody: {
        /**
         * OAuth refresh token. For authorization_code flow, this contains the actual refresh token. For client_credentials flow, this must be set to an empty string.
         */
        refresh_token: string;
        expires_in: number;
        client: string;
        grant_type?: string;
        /**
         * OAuth client ID for resource-level credentials (client_credentials flow only)
         */
        cc_client_id?: string;
        /**
         * OAuth client secret for resource-level credentials (client_credentials flow only)
         */
        cc_client_secret?: string;
        /**
         * OAuth token URL override for resource-level authentication (client_credentials flow only)
         */
        cc_token_url?: string;
        /**
         * MCP server URL for MCP OAuth token refresh
         */
        mcp_server_url?: string;
        /**
         * OAuth scopes to use for token refresh. Overrides instance-level scopes.
         */
        scopes?: Array<(string)>;
    };
    workspace: string;
};
export type CreateAccountResponse = string;
export type ConnectClientCredentialsData = {
    /**
     * OAuth client name
     */
    client: string;
    /**
     * client credentials flow parameters
     */
    requestBody: {
        scopes?: Array<(string)>;
        /**
         * OAuth client ID for resource-level authentication
         */
        cc_client_id: string;
        /**
         * OAuth client secret for resource-level authentication
         */
        cc_client_secret: string;
        /**
         * OAuth token URL override for resource-level authentication
         */
        cc_token_url?: string;
    };
};
export type ConnectClientCredentialsResponse = TokenResponse;
export type RefreshTokenData = {
    id: number;
    /**
     * variable path
     */
    requestBody: {
        path: string;
    };
    workspace: string;
};
export type RefreshTokenResponse = string;
export type DisconnectAccountData = {
    id: number;
    workspace: string;
};
export type DisconnectAccountResponse = string;
export type DisconnectSlackData = {
    workspace: string;
};
export type DisconnectSlackResponse = string;
export type DisconnectTeamsData = {
    workspace: string;
};
export type DisconnectTeamsResponse = string;
export type ListOauthLoginsResponse = {
    oauth: Array<{
        type: string;
        display_name?: string;
    }>;
    saml?: string;
    /**
     * provider type to auto-redirect to on login (oauth key or "saml")
     */
    auto_login?: string;
};
export type ListOauthConnectsResponse = Array<(string)>;
export type GetOauthConnectData = {
    /**
     * client name
     */
    client: string;
};
export type GetOauthConnectResponse = {
    extra_params?: {
        [key: string]: unknown;
    };
    scopes?: Array<(string)>;
    grant_types?: Array<(string)>;
};
export type SendMessageToConversationData = {
    requestBody: {
        /**
         * The ID of the Teams conversation/activity
         */
        conversation_id: string;
        /**
         * Used for styling the card conditionally
         */
        success?: boolean;
        /**
         * The message text to be sent in the Teams card
         */
        text: string;
        /**
         * The card block to be sent in the Teams card
         */
        card_block?: {
            [key: string]: unknown;
        };
    };
};
export type SendMessageToConversationResponse = unknown;
export type CreateResourceData = {
    /**
     * new resource
     */
    requestBody: CreateResource;
    /**
     * update the resource if it already exists (default false)
     */
    updateIfExists?: boolean;
    workspace: string;
};
export type CreateResourceResponse = string;
export type DeleteResourceData = {
    path: string;
    workspace: string;
};
export type DeleteResourceResponse = string;
export type DeleteResourcesBulkData = {
    /**
     * paths to delete
     */
    requestBody: {
        paths: Array<(string)>;
    };
    workspace: string;
};
export type DeleteResourcesBulkResponse = Array<(string)>;
export type UpdateResourceData = {
    path: string;
    /**
     * updated resource
     */
    requestBody: EditResource;
    workspace: string;
};
export type UpdateResourceResponse = string;
export type UpdateResourceValueData = {
    path: string;
    /**
     * updated resource
     */
    requestBody: {
        value?: unknown;
    };
    workspace: string;
};
export type UpdateResourceValueResponse = string;
export type GetResourceData = {
    path: string;
    workspace: string;
};
export type GetResourceResponse = Resource;
export type GetResourceValueInterpolatedData = {
    /**
     * allow getting a cached value for improved performance
     */
    allowCache?: boolean;
    /**
     * job id
     */
    jobId?: string;
    path: string;
    workspace: string;
};
export type GetResourceValueInterpolatedResponse = unknown;
export type GetResourceValueData = {
    path: string;
    workspace: string;
};
export type GetResourceValueResponse = unknown;
export type GetGitCommitHashData = {
    gitSshIdentity?: string;
    path: string;
    workspace: string;
};
export type GetGitCommitHashResponse = {
    /**
     * Latest commit hash from git ls-remote
     */
    commit_hash: string;
};
export type ExistsResourceData = {
    path: string;
    workspace: string;
};
export type ExistsResourceResponse = boolean;
export type ListResourceData = {
    /**
     * broad search across multiple fields (case-insensitive substring match)
     */
    broadFilter?: string;
    /**
     * pattern match filter for description field (case-insensitive)
     */
    description?: string;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * exact path match filter
     */
    path?: string;
    /**
     * filter resources by path prefix
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * resource_types to list from, separated by ',',
     */
    resourceType?: string;
    /**
     * resource_types to not list from, separated by ',',
     */
    resourceTypeExclude?: string;
    /**
     * JSONB subset match filter using base64 encoded JSON
     */
    value?: string;
    workspace: string;
};
export type ListResourceResponse = Array<ListableResource>;
export type ListSearchResourceData = {
    workspace: string;
};
export type ListSearchResourceResponse = Array<{
    path: string;
    value: unknown;
}>;
export type GetMcpToolsData = {
    path: string;
    workspace: string;
};
export type GetMcpToolsResponse = Array<{
    name: string;
    description?: string;
    parameters: {
        [key: string]: unknown;
    };
}>;
export type ListResourceNamesData = {
    name: string;
    workspace: string;
};
export type ListResourceNamesResponse = Array<{
    name: string;
    path: string;
}>;
export type CreateResourceTypeData = {
    /**
     * new resource_type
     */
    requestBody: ResourceType;
    workspace: string;
};
export type CreateResourceTypeResponse = string;
export type FileResourceTypeToFileExtMapData = {
    workspace: string;
};
export type FileResourceTypeToFileExtMapResponse = {
    [key: string]: {
        format_extension?: string | null;
        is_fileset?: boolean;
    };
};
export type DeleteResourceTypeData = {
    path: string;
    workspace: string;
};
export type DeleteResourceTypeResponse = string;
export type UpdateResourceTypeData = {
    path: string;
    /**
     * updated resource_type
     */
    requestBody: EditResourceType;
    workspace: string;
};
export type UpdateResourceTypeResponse = string;
export type GetResourceTypeData = {
    path: string;
    workspace: string;
};
export type GetResourceTypeResponse = ResourceType;
export type ExistsResourceTypeData = {
    path: string;
    workspace: string;
};
export type ExistsResourceTypeResponse = boolean;
export type ListResourceTypeData = {
    workspace: string;
};
export type ListResourceTypeResponse = Array<ResourceType>;
export type ListResourceTypeNamesData = {
    workspace: string;
};
export type ListResourceTypeNamesResponse = Array<(string)>;
export type QueryResourceTypesData = {
    /**
     * query limit
     */
    limit?: number;
    /**
     * query text
     */
    text: string;
    workspace: string;
};
export type QueryResourceTypesResponse = Array<{
    name: string;
    score: number;
    schema?: unknown;
}>;
export type CreateConnectionData = {
    /**
     * new connection
     */
    requestBody: CreateResource;
    /**
     * update the connection if it already exists (default false)
     */
    updateIfExists?: boolean;
    workspace: string;
};
export type CreateConnectionResponse = string;
export type DeleteConnectionData = {
    path: string;
    workspace: string;
};
export type DeleteConnectionResponse = string;
export type DeleteConnectionsBulkData = {
    /**
     * paths to delete
     */
    requestBody: {
        paths: Array<(string)>;
    };
    workspace: string;
};
export type DeleteConnectionsBulkResponse = Array<(string)>;
export type UpdateConnectionData = {
    path: string;
    /**
     * updated connection
     */
    requestBody: EditResource;
    workspace: string;
};
export type UpdateConnectionResponse = string;
export type UpdateConnectionValueData = {
    path: string;
    /**
     * updated connection
     */
    requestBody: {
        value?: unknown;
    };
    workspace: string;
};
export type UpdateConnectionValueResponse = string;
export type GetConnectionData = {
    path: string;
    workspace: string;
};
export type GetConnectionResponse = Resource;
export type GetConnectionValueInterpolatedData = {
    /**
     * allow getting a cached value for improved performance
     */
    allowCache?: boolean;
    /**
     * job id
     */
    jobId?: string;
    path: string;
    workspace: string;
};
export type GetConnectionValueInterpolatedResponse = unknown;
export type GetConnectionValueData = {
    path: string;
    workspace: string;
};
export type GetConnectionValueResponse = unknown;
export type GetGitCommitHashForConnectionData = {
    gitSshIdentity?: string;
    path: string;
    workspace: string;
};
export type GetGitCommitHashForConnectionResponse = {
    /**
     * Latest commit hash from git ls-remote
     */
    commit_hash: string;
};
export type ExistsConnectionData = {
    path: string;
    workspace: string;
};
export type ExistsConnectionResponse = boolean;
export type ListConnectionData = {
    /**
     * broad search across multiple fields (case-insensitive substring match)
     */
    broadFilter?: string;
    /**
     * connection_types to list from, separated by ',',
     */
    connectionType?: string;
    /**
     * connection_types to not list from, separated by ',',
     */
    connectionTypeExclude?: string;
    /**
     * pattern match filter for description field (case-insensitive)
     */
    description?: string;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * exact path match filter
     */
    path?: string;
    /**
     * filter connections by path prefix
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * JSONB subset match filter using base64 encoded JSON
     */
    value?: string;
    workspace: string;
};
export type ListConnectionResponse = Array<ListableResource>;
export type ListSearchConnectionData = {
    workspace: string;
};
export type ListSearchConnectionResponse = Array<{
    path: string;
    value: unknown;
}>;
export type GetMcpToolsForConnectionData = {
    path: string;
    workspace: string;
};
export type GetMcpToolsForConnectionResponse = Array<{
    name: string;
    description?: string;
    parameters: {
        [key: string]: unknown;
    };
}>;
export type ListConnectionNamesData = {
    name: string;
    workspace: string;
};
export type ListConnectionNamesResponse = Array<{
    name: string;
    path: string;
}>;
export type CreateConnectionTypeData = {
    /**
     * new connection_type
     */
    requestBody: ResourceType;
    workspace: string;
};
export type CreateConnectionTypeResponse = string;
export type FileConnectionTypeToFileExtMapData = {
    workspace: string;
};
export type FileConnectionTypeToFileExtMapResponse = {
    [key: string]: {
        format_extension?: string | null;
        is_fileset?: boolean;
    };
};
export type DeleteConnectionTypeData = {
    path: string;
    workspace: string;
};
export type DeleteConnectionTypeResponse = string;
export type UpdateConnectionTypeData = {
    path: string;
    /**
     * updated connection_type
     */
    requestBody: EditResourceType;
    workspace: string;
};
export type UpdateConnectionTypeResponse = string;
export type GetConnectionTypeData = {
    path: string;
    workspace: string;
};
export type GetConnectionTypeResponse = ResourceType;
export type ExistsConnectionTypeData = {
    path: string;
    workspace: string;
};
export type ExistsConnectionTypeResponse = boolean;
export type ListConnectionTypeData = {
    workspace: string;
};
export type ListConnectionTypeResponse = Array<ResourceType>;
export type ListConnectionTypeNamesData = {
    workspace: string;
};
export type ListConnectionTypeNamesResponse = Array<(string)>;
export type GetNpmPackageMetadataData = {
    /**
     * npm package name
     */
    _package: string;
    workspace: string;
};
export type GetNpmPackageMetadataResponse = {
    tags?: {
        [key: string]: (string);
    };
    versions?: Array<(string)>;
};
export type ResolveNpmPackageVersionData = {
    /**
     * npm package name
     */
    _package: string;
    /**
     * version tag or reference
     */
    tag?: string;
    workspace: string;
};
export type ResolveNpmPackageVersionResponse = {
    version?: string | null;
};
export type GetNpmPackageFiletreeData = {
    /**
     * npm package name
     */
    _package: string;
    /**
     * package version
     */
    version: string;
    workspace: string;
};
export type GetNpmPackageFiletreeResponse = {
    default?: string;
    files?: Array<{
        name?: string;
    }>;
};
export type GetNpmPackageFileData = {
    /**
     * npm package name
     */
    _package: string;
    /**
     * file path within package
     */
    filepath: string;
    /**
     * package version
     */
    version: string;
    workspace: string;
};
export type GetNpmPackageFileResponse = string;
export type ListHubIntegrationsData = {
    /**
     * query integrations kind
     */
    kind?: string;
};
export type ListHubIntegrationsResponse = Array<{
    name: string;
}>;
export type ListHubFlowsResponse = {
    flows?: Array<{
        id: number;
        flow_id: number;
        summary: string;
        apps: Array<(string)>;
        approved: boolean;
        votes: number;
    }>;
};
export type GetHubFlowByIdData = {
    id: number;
};
export type GetHubFlowByIdResponse = {
    flow?: OpenFlow;
};
export type ListFlowPathsData = {
    workspace: string;
};
export type ListFlowPathsResponse = Array<(string)>;
export type ListSearchFlowData = {
    workspace: string;
};
export type ListSearchFlowResponse = Array<{
    path: string;
    value: unknown;
}>;
export type ListFlowsData = {
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * (default regardless)
     * If true, show only flows with dedicated_worker enabled.
     * If false, show only flows with dedicated_worker disabled.
     *
     */
    dedicatedWorker?: boolean;
    /**
     * (default false)
     * include items that have no deployed version
     *
     */
    includeDraftOnly?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * mask to filter exact matching path
     */
    pathExact?: string;
    /**
     * mask to filter matching starting path
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * (default false)
     * show only the archived files.
     * when multiple archived hash share the same path, only the ones with the latest create_at
     * are displayed.
     *
     */
    showArchived?: boolean;
    /**
     * (default false)
     * show only the starred items
     *
     */
    starredOnly?: boolean;
    /**
     * (default false)
     * include deployment message
     *
     */
    withDeploymentMsg?: boolean;
    /**
     * (default false)
     * If true, the description field will be omitted from the response.
     *
     */
    withoutDescription?: boolean;
    workspace: string;
};
export type ListFlowsResponse = Array<(Flow & {
    has_draft?: boolean;
    draft_only?: boolean;
})>;
export type GetFlowHistoryData = {
    path: string;
    workspace: string;
};
export type GetFlowHistoryResponse = Array<FlowVersion>;
export type GetFlowLatestVersionData = {
    path: string;
    workspace: string;
};
export type GetFlowLatestVersionResponse = FlowVersion;
export type ListFlowPathsFromWorkspaceRunnableData = {
    matchPathStart?: boolean;
    path: string;
    runnableKind: 'script' | 'flow';
    workspace: string;
};
export type ListFlowPathsFromWorkspaceRunnableResponse = Array<(string)>;
export type GetFlowVersionData = {
    version: number;
    workspace: string;
};
export type GetFlowVersionResponse = Flow;
export type UpdateFlowHistoryData = {
    /**
     * Flow deployment message
     */
    requestBody: {
        deployment_msg: string;
    };
    version: number;
    workspace: string;
};
export type UpdateFlowHistoryResponse = string;
export type GetFlowByPathData = {
    path: string;
    withStarredInfo?: boolean;
    workspace: string;
};
export type GetFlowByPathResponse = Flow;
export type GetFlowDeploymentStatusData = {
    path: string;
    workspace: string;
};
export type GetFlowDeploymentStatusResponse = {
    lock_error_logs?: string;
    job_id?: string;
};
export type GetTriggersCountOfFlowData = {
    path: string;
    workspace: string;
};
export type GetTriggersCountOfFlowResponse = TriggersCount;
export type ListTokensOfFlowData = {
    path: string;
    workspace: string;
};
export type ListTokensOfFlowResponse = Array<TruncatedToken>;
export type ToggleWorkspaceErrorHandlerForFlowData = {
    path: string;
    /**
     * Workspace error handler enabled
     */
    requestBody: {
        muted?: boolean;
    };
    workspace: string;
};
export type ToggleWorkspaceErrorHandlerForFlowResponse = string;
export type GetFlowByPathWithDraftData = {
    path: string;
    workspace: string;
};
export type GetFlowByPathWithDraftResponse = Flow & {
    draft?: Flow;
};
export type ExistsFlowByPathData = {
    path: string;
    workspace: string;
};
export type ExistsFlowByPathResponse = boolean;
export type CreateFlowData = {
    /**
     * Partially filled flow
     */
    requestBody: OpenFlowWPath & {
        draft_only?: boolean;
        deployment_message?: string;
    };
    workspace: string;
};
export type CreateFlowResponse = string;
export type UpdateFlowData = {
    path: string;
    /**
     * Partially filled flow
     */
    requestBody: OpenFlowWPath & {
        deployment_message?: string;
    };
    workspace: string;
};
export type UpdateFlowResponse = string;
export type ArchiveFlowByPathData = {
    path: string;
    /**
     * archiveFlow
     */
    requestBody: {
        archived?: boolean;
    };
    workspace: string;
};
export type ArchiveFlowByPathResponse = string;
export type DeleteFlowByPathData = {
    /**
     * keep captures
     */
    keepCaptures?: boolean;
    path: string;
    workspace: string;
};
export type DeleteFlowByPathResponse = string;
export type ListHubAppsResponse = {
    apps?: Array<{
        id: number;
        app_id: number;
        summary: string;
        apps: Array<(string)>;
        approved: boolean;
        votes: number;
    }>;
};
export type GetHubAppByIdData = {
    id: number;
};
export type GetHubAppByIdResponse = {
    app: {
        summary: string;
        value: unknown;
    };
};
export type GetHubRawAppByIdData = {
    id: number;
};
export type GetHubRawAppByIdResponse = {
    app: {
        summary: string;
        value: unknown;
    };
};
export type GetPublicAppByCustomPathData = {
    customPath: string;
};
export type GetPublicAppByCustomPathResponse = AppWithLastVersion & {
    workspace_id?: string;
};
export type GetRawAppDataData = {
    secretWithExtension: string;
    workspace: string;
};
export type GetRawAppDataResponse = string;
export type ListSearchAppData = {
    workspace: string;
};
export type ListSearchAppResponse = Array<{
    path: string;
    value: unknown;
}>;
export type ListAppsData = {
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * (default false)
     * include items that have no deployed version
     *
     */
    includeDraftOnly?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * mask to filter exact matching path
     */
    pathExact?: string;
    /**
     * mask to filter matching starting path
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * (default false)
     * show only the starred items
     *
     */
    starredOnly?: boolean;
    /**
     * (default false)
     * include deployment message
     *
     */
    withDeploymentMsg?: boolean;
    workspace: string;
};
export type ListAppsResponse = Array<ListableApp>;
export type CreateAppData = {
    /**
     * new app
     */
    requestBody: {
        path: string;
        value: unknown;
        summary: string;
        policy: Policy;
        draft_only?: boolean;
        deployment_message?: string;
        custom_path?: string;
        /**
         * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
         */
        preserve_on_behalf_of?: boolean;
        labels?: Array<(string)>;
    };
    workspace: string;
};
export type CreateAppResponse = string;
export type CreateAppRawData = {
    /**
     * new app
     */
    formData: {
        app?: {
            path: string;
            value: unknown;
            summary: string;
            policy: Policy;
            draft_only?: boolean;
            deployment_message?: string;
            custom_path?: string;
            /**
             * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
             */
            preserve_on_behalf_of?: boolean;
            labels?: Array<(string)>;
        };
        js?: string;
        css?: string;
    };
    workspace: string;
};
export type CreateAppRawResponse = string;
export type ExistsAppData = {
    path: string;
    workspace: string;
};
export type ExistsAppResponse = boolean;
export type GetAppByPathData = {
    path: string;
    withStarredInfo?: boolean;
    workspace: string;
};
export type GetAppByPathResponse = AppWithLastVersion;
export type GetAppLiteByPathData = {
    path: string;
    workspace: string;
};
export type GetAppLiteByPathResponse = AppWithLastVersion;
export type GetAppByPathWithDraftData = {
    path: string;
    workspace: string;
};
export type GetAppByPathWithDraftResponse = AppWithLastVersionWDraft;
export type GetAppHistoryByPathData = {
    path: string;
    workspace: string;
};
export type GetAppHistoryByPathResponse = Array<AppHistory>;
export type GetAppLatestVersionData = {
    path: string;
    workspace: string;
};
export type GetAppLatestVersionResponse = AppHistory;
export type ListAppPathsFromWorkspaceRunnableData = {
    path: string;
    runnableKind: 'script' | 'flow';
    workspace: string;
};
export type ListAppPathsFromWorkspaceRunnableResponse = Array<(string)>;
export type UpdateAppHistoryData = {
    id: number;
    /**
     * App deployment message
     */
    requestBody: {
        deployment_msg?: string;
    };
    version: number;
    workspace: string;
};
export type UpdateAppHistoryResponse = string;
export type GetPublicAppBySecretData = {
    path: string;
    workspace: string;
};
export type GetPublicAppBySecretResponse = AppWithLastVersion;
export type GetPublicResourceData = {
    path: string;
    workspace: string;
};
export type GetPublicResourceResponse = unknown;
export type GetPublicSecretOfAppData = {
    path: string;
    workspace: string;
};
export type GetPublicSecretOfAppResponse = string;
export type GetPublicSecretOfLatestVersionOfAppData = {
    path: string;
    workspace: string;
};
export type GetPublicSecretOfLatestVersionOfAppResponse = string;
export type GetAppByVersionData = {
    id: number;
    workspace: string;
};
export type GetAppByVersionResponse = AppWithLastVersion;
export type DeleteAppData = {
    path: string;
    workspace: string;
};
export type DeleteAppResponse = string;
export type UpdateAppData = {
    path: string;
    /**
     * update app
     */
    requestBody: {
        path?: string;
        summary?: string;
        value?: unknown;
        policy?: Policy;
        deployment_message?: string;
        custom_path?: string;
        /**
         * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
         */
        preserve_on_behalf_of?: boolean;
        labels?: Array<(string)>;
    };
    workspace: string;
};
export type UpdateAppResponse = string;
export type UpdateAppRawData = {
    /**
     * update app
     */
    formData: {
        app?: {
            path?: string;
            summary?: string;
            value?: unknown;
            policy?: Policy;
            deployment_message?: string;
            custom_path?: string;
            /**
             * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
             */
            preserve_on_behalf_of?: boolean;
            labels?: Array<(string)>;
        };
        js?: string;
        css?: string;
    };
    path: string;
    workspace: string;
};
export type UpdateAppRawResponse = string;
export type CustomPathExistsData = {
    customPath: string;
    workspace: string;
};
export type CustomPathExistsResponse = boolean;
export type SignS3ObjectsData = {
    /**
     * s3 objects to sign
     */
    requestBody: {
        s3_objects: Array<S3Object>;
    };
    workspace: string;
};
export type SignS3ObjectsResponse = Array<S3Object>;
export type ExecuteComponentData = {
    path: string;
    /**
     * update app
     */
    requestBody: {
        component: string;
        path?: string;
        version?: number;
        args: unknown;
        raw_code?: {
            content: string;
            language: string;
            path?: string;
            lock?: string;
            cache_ttl?: number;
            tag?: string;
        };
        id?: number;
        force_viewer_static_fields?: {
            [key: string]: unknown;
        };
        force_viewer_one_of_fields?: {
            [key: string]: unknown;
        };
        force_viewer_allow_user_resources?: Array<(string)>;
        force_viewer_sensitive_inputs?: Array<(string)>;
        force_viewer_delete_after_secs?: number;
        /**
         * Runnable query parameters
         */
        run_query_params?: {
            [key: string]: unknown;
        };
    };
    workspace: string;
};
export type ExecuteComponentResponse = string;
export type UploadS3FileFromAppData = {
    contentDisposition?: string;
    contentType?: string;
    fileExtension?: string;
    fileKey?: string;
    path: string;
    /**
     * File content
     */
    requestBody: (Blob | File);
    resourceType?: string;
    s3ResourcePath?: string;
    storage?: string;
    workspace: string;
};
export type UploadS3FileFromAppResponse = {
    file_key: string;
    delete_token: string;
};
export type DeleteS3FileFromAppData = {
    deleteToken: string;
    workspace: string;
};
export type DeleteS3FileFromAppResponse = string;
export type GetHubScriptContentByPathData = {
    path: string;
};
export type GetHubScriptContentByPathResponse = string;
export type GetHubScriptByPathData = {
    path: string;
};
export type GetHubScriptByPathResponse = {
    content: string;
    lockfile?: string;
    schema?: unknown;
    language: string;
    summary?: string;
};
export type PickHubScriptByPathData = {
    path: string;
};
export type PickHubScriptByPathResponse = {
    success: boolean;
};
export type GetTopHubScriptsData = {
    /**
     * query scripts app
     */
    app?: string;
    /**
     * query scripts kind
     */
    kind?: string;
    /**
     * query limit
     */
    limit?: number;
};
export type GetTopHubScriptsResponse = {
    asks?: Array<{
        id: number;
        ask_id: number;
        summary: string;
        app: string;
        version_id: number;
        kind: HubScriptKind;
        votes: number;
        views: number;
    }>;
};
export type QueryHubScriptsData = {
    /**
     * query scripts app
     */
    app?: string;
    /**
     * query scripts kind
     */
    kind?: string;
    /**
     * query limit
     */
    limit?: number;
    /**
     * query text
     */
    text: string;
};
export type QueryHubScriptsResponse = Array<{
    ask_id: number;
    id: number;
    version_id: number;
    summary: string;
    app: string;
    kind: HubScriptKind;
    score: number;
}>;
export type ListSearchScriptData = {
    workspace: string;
};
export type ListSearchScriptResponse = Array<{
    path: string;
    content: string;
}>;
export type ListScriptsData = {
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * (default regardless)
     * If true, show only scripts with dedicated_worker enabled.
     * If false, show only scripts with dedicated_worker disabled.
     *
     */
    dedicatedWorker?: boolean;
    /**
     * mask to filter scripts whom first direct parent has exact hash
     */
    firstParentHash?: string;
    /**
     * (default false)
     * include scripts that have no deployed version
     *
     */
    includeDraftOnly?: boolean;
    /**
     * (default false)
     * include scripts without an exported main function
     *
     */
    includeWithoutMain?: boolean;
    /**
     * (default regardless)
     * if true show only the templates
     * if false show only the non templates
     * if not defined, show all regardless of if the script is a template
     *
     */
    isTemplate?: boolean;
    /**
     * (default regardless)
     * script kinds to filter, split by comma
     *
     */
    kinds?: string;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * Filter to only include scripts written in the given languages.
     * Accepts multiple values as a comma-separated list.
     *
     */
    languages?: string;
    /**
     * mask to filter scripts whom last parent in the chain has exact hash.
     * Beware that each script stores only a limited number of parents. Hence
     * the last parent hash for a script is not necessarily its top-most parent.
     * To find the top-most parent you will have to jump from last to last hash
     * until finding the parent
     *
     */
    lastParentHash?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * is the hash present in the array of stored parent hashes for this script.
     * The same warning applies than for last_parent_hash. A script only store a
     * limited number of direct parent
     *
     */
    parentHash?: string;
    /**
     * mask to filter exact matching path
     */
    pathExact?: string;
    /**
     * mask to filter matching starting path
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * (default false)
     * show only the archived files.
     * when multiple archived hash share the same path, only the ones with the latest create_at
     * are
     * ed.
     *
     */
    showArchived?: boolean;
    /**
     * (default false)
     * show only the starred items
     *
     */
    starredOnly?: boolean;
    /**
     * (default false)
     * include deployment message
     *
     */
    withDeploymentMsg?: boolean;
    /**
     * (default false)
     * If true, the description field will be omitted from the response.
     *
     */
    withoutDescription?: boolean;
    workspace: string;
};
export type ListScriptsResponse = Array<Script>;
export type ListScriptPathsData = {
    workspace: string;
};
export type ListScriptPathsResponse = Array<(string)>;
export type CreateScriptData = {
    /**
     * Partially filled script
     */
    requestBody: NewScript;
    workspace: string;
};
export type CreateScriptResponse = string;
export type ToggleWorkspaceErrorHandlerForScriptData = {
    path: string;
    /**
     * Workspace error handler enabled
     */
    requestBody: {
        muted?: boolean;
    };
    workspace: string;
};
export type ToggleWorkspaceErrorHandlerForScriptResponse = string;
export type ArchiveScriptByPathData = {
    path: string;
    workspace: string;
};
export type ArchiveScriptByPathResponse = string;
export type ArchiveScriptByHashData = {
    hash: string;
    workspace: string;
};
export type ArchiveScriptByHashResponse = Script;
export type DeleteScriptByHashData = {
    hash: string;
    workspace: string;
};
export type DeleteScriptByHashResponse = Script;
export type DeleteScriptByPathData = {
    /**
     * keep captures
     */
    keepCaptures?: boolean;
    path: string;
    workspace: string;
};
export type DeleteScriptByPathResponse = string;
export type DeleteScriptsBulkData = {
    /**
     * paths to delete
     */
    requestBody: {
        paths: Array<(string)>;
    };
    workspace: string;
};
export type DeleteScriptsBulkResponse = Array<(string)>;
export type GetScriptByPathData = {
    path: string;
    withStarredInfo?: boolean;
    workspace: string;
};
export type GetScriptByPathResponse = Script;
export type GetTriggersCountOfScriptData = {
    path: string;
    workspace: string;
};
export type GetTriggersCountOfScriptResponse = TriggersCount;
export type ListTokensOfScriptData = {
    path: string;
    workspace: string;
};
export type ListTokensOfScriptResponse = Array<TruncatedToken>;
export type GetScriptByPathWithDraftData = {
    path: string;
    workspace: string;
};
export type GetScriptByPathWithDraftResponse = NewScriptWithDraft;
export type GetScriptHistoryByPathData = {
    path: string;
    workspace: string;
};
export type GetScriptHistoryByPathResponse = Array<ScriptHistory>;
export type ListScriptPathsFromWorkspaceRunnableData = {
    path: string;
    workspace: string;
};
export type ListScriptPathsFromWorkspaceRunnableResponse = Array<(string)>;
export type GetScriptLatestVersionData = {
    path: string;
    workspace: string;
};
export type GetScriptLatestVersionResponse = ScriptHistory;
export type UpdateScriptHistoryData = {
    hash: string;
    path: string;
    /**
     * Script deployment message
     */
    requestBody: {
        deployment_msg?: string;
    };
    workspace: string;
};
export type UpdateScriptHistoryResponse = string;
export type ListDedicatedWithDepsData = {
    workspace: string;
};
export type ListDedicatedWithDepsResponse = Array<{
    path: string;
    language: 'python3' | 'deno' | 'go' | 'bash' | 'powershell' | 'postgresql' | 'mysql' | 'bigquery' | 'snowflake' | 'mssql' | 'graphql' | 'nativets' | 'bun' | 'bunnative' | 'php' | 'rust' | 'ansible' | 'csharp' | 'oracledb' | 'duckdb' | 'java' | 'ruby' | 'mongodb' | 'groovy' | 'kotlin' | 'dart';
    workspace_dep_names: Array<(string)>;
}>;
export type RawScriptByPathData = {
    path: string;
    workspace: string;
};
export type RawScriptByPathResponse = string;
export type RawScriptByPathTokenedData = {
    path: string;
    token: string;
    workspace: string;
};
export type RawScriptByPathTokenedResponse = string;
export type ExistsScriptByPathData = {
    path: string;
    workspace: string;
};
export type ExistsScriptByPathResponse = boolean;
export type GetScriptByHashData = {
    authed?: boolean;
    hash: string;
    withStarredInfo?: boolean;
    workspace: string;
};
export type GetScriptByHashResponse = Script;
export type RawScriptByHashData = {
    path: string;
    workspace: string;
};
export type RawScriptByHashResponse = string;
export type GetScriptDeploymentStatusData = {
    hash: string;
    workspace: string;
};
export type GetScriptDeploymentStatusResponse = {
    lock?: string;
    lock_error_logs?: string;
    job_id?: string;
};
export type GetCiTestResultsData = {
    kind: 'script' | 'flow' | 'resource';
    path: string;
    workspace: string;
};
export type GetCiTestResultsResponse = Array<CiTestResult>;
export type GetCiTestResultsBatchData = {
    requestBody: {
        items: Array<{
            path: string;
            kind: 'script' | 'flow' | 'resource';
        }>;
    };
    workspace: string;
};
export type GetCiTestResultsBatchResponse = {
    [key: string]: Array<CiTestResult>;
};
export type StoreRawScriptTempData = {
    /**
     * script content to store
     */
    requestBody: string;
    workspace: string;
};
export type StoreRawScriptTempResponse = string;
export type DiffRawScriptsWithDeployedData = {
    /**
     * scripts and workspace deps to diff against deployed versions
     */
    requestBody: {
        /**
         * map of script path to SHA256 content hash
         */
        scripts: {
            [key: string]: (string);
        };
        /**
         * workspace dependencies to diff
         */
        workspace_deps?: Array<{
            /**
             * CLI path (e.g. dependencies/package.json)
             */
            path: string;
            language: ScriptLang;
            /**
             * named workspace dependency (null for default)
             */
            name?: string;
            /**
             * SHA256 content hash
             */
            hash: string;
        }>;
    };
    workspace: string;
};
export type DiffRawScriptsWithDeployedResponse = Array<(string)>;
export type CreateDraftData = {
    requestBody: {
        path: string;
        typ: 'flow' | 'script' | 'app' | 'bpmn' | 'dmn_decision';
        value?: unknown;
    };
    workspace: string;
};
export type CreateDraftResponse = string;
export type DeleteDraftData = {
    kind: 'script' | 'flow' | 'app';
    path: string;
    workspace: string;
};
export type DeleteDraftResponse = string;
export type GetCustomTagsData = {
    showWorkspaceRestriction?: boolean;
};
export type GetCustomTagsResponse = Array<(string)>;
export type GetCustomTagsForWorkspaceData = {
    workspace: string;
};
export type GetCustomTagsForWorkspaceResponse = Array<(string)>;
export type GeDefaultTagsResponse = Array<(string)>;
export type IsDefaultTagsPerWorkspaceResponse = boolean;
export type ListWorkersData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * number of seconds the worker must have had a last ping more recent of (default to 300)
     */
    pingSince?: number;
};
export type ListWorkersResponse = Array<WorkerPing>;
export type ExistsWorkersWithTagsData = {
    /**
     * comma separated list of tags
     */
    tags: string;
    /**
     * workspace to filter tags visibility (required when TAGS_ARE_SENSITIVE is enabled for non-superadmins)
     */
    workspace?: string;
};
export type ExistsWorkersWithTagsResponse = {
    [key: string]: (boolean);
};
export type GetQueueMetricsResponse = Array<{
    id: string;
    values: Array<{
        created_at: string;
        value: number;
    }>;
}>;
export type GetCountsOfJobsWaitingPerTagResponse = {
    [key: string]: (number);
};
export type GetCountsOfRunningJobsPerTagResponse = {
    [key: string]: (number);
};
export type CreateWorkspaceDependenciesData = {
    /**
     * New workspace dependencies
     */
    requestBody: NewWorkspaceDependencies;
    workspace: string;
};
export type CreateWorkspaceDependenciesResponse = string;
export type ArchiveWorkspaceDependenciesData = {
    language: ScriptLang;
    name?: string;
    workspace: string;
};
export type ArchiveWorkspaceDependenciesResponse = unknown;
export type DeleteWorkspaceDependenciesData = {
    language: ScriptLang;
    name?: string;
    workspace: string;
};
export type DeleteWorkspaceDependenciesResponse = unknown;
export type ListWorkspaceDependenciesData = {
    workspace: string;
};
export type ListWorkspaceDependenciesResponse = Array<WorkspaceDependencies>;
export type GetLatestWorkspaceDependenciesData = {
    language: ScriptLang;
    name?: string;
    workspace: string;
};
export type GetLatestWorkspaceDependenciesResponse = WorkspaceDependencies;
export type ListSelectedJobGroupsData = {
    /**
     * script args
     */
    requestBody: Array<(string)>;
    workspace: string;
};
export type ListSelectedJobGroupsResponse = Array<{
    kind: 'script' | 'flow';
    script_path: string;
    latest_schema: {
        [key: string]: unknown;
    };
    schemas: Array<{
        schema: {
            [key: string]: unknown;
        };
        script_hash: string;
        job_ids: Array<(string)>;
    }>;
}>;
export type RunScriptByPathData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    /**
     * make the run invisible to the the script owner (default false)
     */
    invisibleToOwner?: boolean;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    path: string;
    /**
     * script args
     */
    requestBody: ScriptArgs;
    /**
     * when to schedule this job (leave empty for immediate run)
     */
    scheduledFor?: string;
    /**
     * schedule the script to execute in the number of seconds starting now
     */
    scheduledInSecs?: number;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunScriptByPathResponse = string;
export type RunWaitResultScriptByPathData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    path: string;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * script args
     */
    requestBody: ScriptArgs;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunWaitResultScriptByPathResponse = unknown;
export type RunWaitResultScriptByPathGetData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    path: string;
    /**
     * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
     * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
     *
     */
    payload?: string;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunWaitResultScriptByPathGetResponse = unknown;
export type RunWaitResultFlowByPathData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    path: string;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * script args
     */
    requestBody: ScriptArgs;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    workspace: string;
};
export type RunWaitResultFlowByPathResponse = unknown;
export type RunWaitResultFlowByVersionData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * script args
     */
    requestBody: ScriptArgs;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * flow version ID
     */
    version: number;
    workspace: string;
};
export type RunWaitResultFlowByVersionResponse = unknown;
export type RunWaitResultFlowByVersionGetData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
     * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
     *
     */
    payload?: string;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * flow version ID
     */
    version: number;
    workspace: string;
};
export type RunWaitResultFlowByVersionGetResponse = unknown;
export type RunAndStreamFlowByPathData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    path: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * flow args
     */
    requestBody: ScriptArgs;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    workspace: string;
};
export type RunAndStreamFlowByPathResponse = string;
export type RunAndStreamFlowByPathGetData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    path: string;
    /**
     * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
     * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
     *
     */
    payload?: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    workspace: string;
};
export type RunAndStreamFlowByPathGetResponse = string;
export type RunAndStreamFlowByVersionData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * flow args
     */
    requestBody: ScriptArgs;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * flow version ID
     */
    version: number;
    workspace: string;
};
export type RunAndStreamFlowByVersionResponse = string;
export type RunAndStreamFlowByVersionGetData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
     * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
     *
     */
    payload?: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * flow version ID
     */
    version: number;
    workspace: string;
};
export type RunAndStreamFlowByVersionGetResponse = string;
export type RunAndStreamScriptByPathData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    path: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * script args
     */
    requestBody: ScriptArgs;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunAndStreamScriptByPathResponse = string;
export type RunAndStreamScriptByPathGetData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    path: string;
    /**
     * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
     * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
     *
     */
    payload?: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunAndStreamScriptByPathGetResponse = string;
export type RunAndStreamScriptByHashData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    hash: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * script args
     */
    requestBody: ScriptArgs;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunAndStreamScriptByHashResponse = string;
export type RunAndStreamScriptByHashGetData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    hash: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
     * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
     *
     */
    payload?: string;
    /**
     * delay between polling for job updates in milliseconds
     */
    pollDelayMs?: number;
    /**
     * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
     *
     */
    queueLimit?: string;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunAndStreamScriptByHashGetResponse = string;
export type ResultByIdData = {
    flowJobId: string;
    nodeId: string;
    workspace: string;
};
export type ResultByIdResponse = unknown;
export type RunFlowByPathData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * make the run invisible to the the flow owner (default false)
     */
    invisibleToOwner?: boolean;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    path: string;
    /**
     * flow args
     */
    requestBody: ScriptArgs;
    /**
     * when to schedule this job (leave empty for immediate run)
     */
    scheduledFor?: string;
    /**
     * schedule the script to execute in the number of seconds starting now
     */
    scheduledInSecs?: number;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunFlowByPathResponse = string;
export type RunFlowByVersionData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * make the run invisible to the the flow owner (default false)
     */
    invisibleToOwner?: boolean;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * flow args
     */
    requestBody: ScriptArgs;
    /**
     * when to schedule this job (leave empty for immediate run)
     */
    scheduledFor?: string;
    /**
     * schedule the script to execute in the number of seconds starting now
     */
    scheduledInSecs?: number;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    /**
     * flow version ID
     */
    version: number;
    workspace: string;
};
export type RunFlowByVersionResponse = string;
export type BatchReRunJobsData = {
    /**
     * list of job ids to re run and arg tranforms
     */
    requestBody: {
        job_ids: Array<(string)>;
        script_options_by_path: {
            [key: string]: {
                input_transforms?: {
                    [key: string]: InputTransform;
                };
                use_latest_version?: boolean;
            };
        };
        flow_options_by_path: {
            [key: string]: {
                input_transforms?: {
                    [key: string]: InputTransform;
                };
                use_latest_version?: boolean;
            };
        };
    };
    workspace: string;
};
export type BatchReRunJobsResponse = string;
export type RestartFlowAtStepData = {
    id: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * make the run invisible to the the flow owner (default false)
     */
    invisibleToOwner?: boolean;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * restart flow parameters
     */
    requestBody: {
        /**
         * top-level step id to restart the flow from (or the outermost container when restarting at a nested step)
         */
        step_id: string;
        /**
         * for branchall or loop at the top level, the iteration at which the flow should restart (optional)
         */
        branch_or_iteration_n?: number;
        /**
         * specific flow version to use for restart (optional, uses current version if not specified)
         */
        flow_version?: number;
        /**
         * path of additional steps to descend into AFTER `step_id`. Each entry represents one level of nesting inside the spawned child of the previous level's container (BranchOne / sequential ForLoop iteration / Subflow). When non-empty, the actual restart point is the LAST entry's step_id.
         */
        nested_path?: Array<{
            /**
             * step id at this nesting level
             */
            step_id: string;
            /**
             * for ForLoop containers, the iteration to restart at (0-based; iterations 0..n-1 are preserved)
             */
            branch_or_iteration_n?: number;
        }>;
    };
    /**
     * when to schedule this job (leave empty for immediate run)
     */
    scheduledFor?: string;
    /**
     * schedule the script to execute in the number of seconds starting now
     */
    scheduledInSecs?: number;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RestartFlowAtStepResponse = string;
export type RunScriptByHashData = {
    /**
     * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
     */
    cacheTtl?: string;
    hash: string;
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * make the run invisible to the the script owner (default false)
     */
    invisibleToOwner?: boolean;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * Partially filled args
     */
    requestBody: {
        [key: string]: unknown;
    };
    /**
     * when to schedule this job (leave empty for immediate run)
     */
    scheduledFor?: string;
    /**
     * schedule the script to execute in the number of seconds starting now
     */
    scheduledInSecs?: number;
    /**
     * skip the preprocessor
     */
    skipPreprocessor?: boolean;
    /**
     * Override the tag to use
     */
    tag?: string;
    workspace: string;
};
export type RunScriptByHashResponse = string;
export type RunScriptPreviewData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * make the run invisible to the the script owner (default false)
     */
    invisibleToOwner?: boolean;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * preview
     */
    requestBody: Preview;
    workspace: string;
};
export type RunScriptPreviewResponse = string;
export type RunScriptPreviewInlineData = {
    /**
     * preview
     */
    requestBody: PreviewInline;
    workspace: string;
};
export type RunScriptPreviewInlineResponse = unknown;
export type RunScriptByPathInlineData = {
    path: string;
    /**
     * script args
     */
    requestBody: InlineScriptArgs;
    workspace: string;
};
export type RunScriptByPathInlineResponse = unknown;
export type RunScriptByHashInlineData = {
    hash: string;
    /**
     * script args
     */
    requestBody: InlineScriptArgs;
    workspace: string;
};
export type RunScriptByHashInlineResponse = unknown;
export type RunScriptPreviewAndWaitResultData = {
    /**
     * preview
     */
    requestBody: Preview;
    workspace: string;
};
export type RunScriptPreviewAndWaitResultResponse = unknown;
export type RunCodeFlowTaskData = {
    entrypoint: string;
    jobId: string;
    /**
     * preview
     */
    requestBody: WorkflowTask;
    workspace: string;
};
export type RunCodeFlowTaskResponse = string;
export type RunRawScriptDependenciesData = {
    /**
     * raw script content
     */
    requestBody: {
        raw_scripts: Array<RawScriptForDependencies>;
        entrypoint: string;
    };
    workspace: string;
};
export type RunRawScriptDependenciesResponse = {
    lock: string;
};
export type RunRawScriptDependenciesAsyncData = {
    /**
     * raw script content
     */
    requestBody: {
        raw_scripts: Array<RawScriptForDependencies>;
        entrypoint: string;
    };
    workspace: string;
};
export type RunRawScriptDependenciesAsyncResponse = string;
export type RunFlowDependenciesAsyncData = {
    /**
     * flow value and path
     */
    requestBody: {
        path: string;
        flow_value: FlowValue;
    };
    workspace: string;
};
export type RunFlowDependenciesAsyncResponse = string;
export type RunFlowPreviewData = {
    /**
     * List of headers's keys (separated with ',') whove value are added to the args
     * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
     *
     */
    includeHeader?: string;
    /**
     * make the run invisible to the the script owner (default false)
     */
    invisibleToOwner?: boolean;
    /**
     * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
     */
    jobId?: string;
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * preview
     */
    requestBody: FlowPreview;
    workspace: string;
};
export type RunFlowPreviewResponse = string;
export type RunFlowPreviewAndWaitResultData = {
    /**
     * memory ID for chat-enabled flows
     */
    memoryId?: string;
    /**
     * preview
     */
    requestBody: FlowPreview;
    workspace: string;
};
export type RunFlowPreviewAndWaitResultResponse = unknown;
export type RunDynamicSelectData = {
    /**
     * dynamic select request
     */
    requestBody: DynamicInputData;
    workspace: string;
};
export type RunDynamicSelectResponse = string;
export type ListQueueData = {
    /**
     * allow wildcards (*) in the filter of label, tag, worker
     */
    allowWildcards?: boolean;
    /**
     * get jobs from all workspaces (only valid if request come from the `admins` workspace)
     */
    allWorkspaces?: boolean;
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * is not a scheduled job
     */
    isNotSchedule?: boolean;
    /**
     * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
     */
    jobKinds?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * filter on jobs containing those result as a json subset (@> in postgres)
     */
    result?: string;
    /**
     * filter on running jobs
     */
    running?: boolean;
    /**
     * filter on jobs scheduled_for before now (hence waitinf for a worker)
     */
    scheduledForBeforeNow?: boolean;
    /**
     * mask to filter by schedule path
     */
    schedulePath?: string;
    /**
     * mask to filter exact matching path
     */
    scriptHash?: string;
    /**
     * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
     */
    scriptPathExact?: string;
    /**
     * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
     */
    scriptPathStart?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    startedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    startedBefore?: string;
    /**
     * filter on successful jobs
     */
    success?: boolean;
    /**
     * filter on suspended jobs
     */
    suspended?: boolean;
    /**
     * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
     */
    tag?: string;
    /**
     * filter by trigger kind. Supports comma-separated list (e.g. 'schedule,webhook') and negation by prefixing all values with '!' (e.g. '!schedule,!webhook')
     */
    triggerKind?: string;
    /**
     * filter by trigger path. Supports comma-separated list (e.g. 'f/trigger1,f/trigger2') and negation by prefixing all values with '!' (e.g. '!f/trigger1,!f/trigger2')
     */
    triggerPath?: string;
    /**
     * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
     */
    worker?: string;
    workspace: string;
};
export type ListQueueResponse = Array<QueuedJob>;
export type GetQueueCountData = {
    /**
     * get jobs from all workspaces (only valid if request come from the `admins` workspace)
     */
    allWorkspaces?: boolean;
    workspace: string;
};
export type GetQueueCountResponse = {
    database_length: number;
    suspended?: number;
};
export type GetCompletedCountData = {
    workspace: string;
};
export type GetCompletedCountResponse = {
    database_length: number;
};
export type CountCompletedJobsData = {
    allWorkspaces?: boolean;
    completedAfterSAgo?: number;
    success?: boolean;
    tags?: string;
    workspace: string;
};
export type CountCompletedJobsResponse = number;
export type ListFilteredJobsUuidsData = {
    /**
     * get jobs from all workspaces (only valid if request come from the `admins` workspace)
     */
    allWorkspaces?: boolean;
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    completedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    completedBefore?: string;
    /**
     * filter on created after (exclusive) timestamp
     */
    createdAfter?: string;
    /**
     * filter on jobs created after X for jobs in the queue only
     */
    createdAfterQueue?: string;
    /**
     * filter on created before (inclusive) timestamp
     */
    createdBefore?: string;
    /**
     * filter on jobs created before X for jobs in the queue only
     */
    createdBeforeQueue?: string;
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * has null parent
     */
    hasNullParent?: boolean;
    /**
     * is the job a flow step
     */
    isFlowStep?: boolean;
    /**
     * is not a scheduled job
     */
    isNotSchedule?: boolean;
    /**
     * is the job skipped
     */
    isSkipped?: boolean;
    /**
     * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
     */
    jobKinds?: string;
    /**
     * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * filter on jobs containing those result as a json subset (@> in postgres)
     */
    result?: string;
    /**
     * filter on running jobs
     */
    running?: boolean;
    /**
     * filter on jobs scheduled_for before now (hence waitinf for a worker)
     */
    scheduledForBeforeNow?: boolean;
    /**
     * mask to filter by schedule path
     */
    schedulePath?: string;
    /**
     * mask to filter exact matching path
     */
    scriptHash?: string;
    /**
     * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
     */
    scriptPathExact?: string;
    /**
     * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
     */
    scriptPathStart?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    startedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    startedBefore?: string;
    /**
     * filter on successful jobs
     */
    success?: boolean;
    /**
     * filter on suspended jobs
     */
    suspended?: boolean;
    /**
     * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
     */
    tag?: string;
    /**
     * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
     */
    worker?: string;
    workspace: string;
};
export type ListFilteredJobsUuidsResponse = Array<(string)>;
export type ListFilteredQueueUuidsData = {
    /**
     * allow wildcards (*) in the filter of label, tag, worker
     */
    allowWildcards?: boolean;
    /**
     * get jobs from all workspaces (only valid if request come from the `admins` workspace)
     */
    allWorkspaces?: boolean;
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    concurrencyKey?: string;
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * is not a scheduled job
     */
    isNotSchedule?: boolean;
    /**
     * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
     */
    jobKinds?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * filter on jobs containing those result as a json subset (@> in postgres)
     */
    result?: string;
    /**
     * filter on running jobs
     */
    running?: boolean;
    /**
     * filter on jobs scheduled_for before now (hence waitinf for a worker)
     */
    scheduledForBeforeNow?: boolean;
    /**
     * mask to filter by schedule path
     */
    schedulePath?: string;
    /**
     * mask to filter exact matching path
     */
    scriptHash?: string;
    /**
     * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
     */
    scriptPathExact?: string;
    /**
     * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
     */
    scriptPathStart?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    startedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    startedBefore?: string;
    /**
     * filter on successful jobs
     */
    success?: boolean;
    /**
     * filter on suspended jobs
     */
    suspended?: boolean;
    /**
     * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
     */
    tag?: string;
    workspace: string;
};
export type ListFilteredQueueUuidsResponse = Array<(string)>;
export type CancelSelectionData = {
    allWorkspaces?: boolean;
    forceCancel?: boolean;
    /**
     * uuids of the jobs to cancel
     */
    requestBody: Array<(string)>;
    workspace: string;
};
export type CancelSelectionResponse = Array<(string)>;
export type GetJobOtelTracesData = {
    id: string;
    workspace: string;
};
export type GetJobOtelTracesResponse = Array<{
    [key: string]: unknown;
}>;
export type ListCompletedJobsData = {
    /**
     * allow wildcards (*) in the filter of label, tag, worker
     */
    allowWildcards?: boolean;
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * has null parent
     */
    hasNullParent?: boolean;
    /**
     * is the job a flow step
     */
    isFlowStep?: boolean;
    /**
     * is not a scheduled job
     */
    isNotSchedule?: boolean;
    /**
     * is the job skipped
     */
    isSkipped?: boolean;
    /**
     * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
     */
    jobKinds?: string;
    /**
     * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
     */
    label?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * filter on jobs containing those result as a json subset (@> in postgres)
     */
    result?: string;
    /**
     * mask to filter by schedule path
     */
    schedulePath?: string;
    /**
     * mask to filter exact matching path
     */
    scriptHash?: string;
    /**
     * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
     */
    scriptPathExact?: string;
    /**
     * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
     */
    scriptPathStart?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    startedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    startedBefore?: string;
    /**
     * filter on successful jobs
     */
    success?: boolean;
    /**
     * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
     */
    tag?: string;
    /**
     * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
     */
    worker?: string;
    workspace: string;
};
export type ListCompletedJobsResponse = Array<CompletedJob>;
export type ExportCompletedJobsData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ExportCompletedJobsResponse = Array<ExportableCompletedJob>;
export type ImportCompletedJobsData = {
    requestBody: Array<ExportableCompletedJob>;
    workspace: string;
};
export type ImportCompletedJobsResponse = string;
export type ExportQueuedJobsData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ExportQueuedJobsResponse = Array<ExportableQueuedJob>;
export type ImportQueuedJobsData = {
    requestBody: Array<ExportableQueuedJob>;
    workspace: string;
};
export type ImportQueuedJobsResponse = string;
export type DeleteJobsData = {
    requestBody: Array<(string)>;
    workspace: string;
};
export type DeleteJobsResponse = string;
export type ListJobsData = {
    /**
     * allow wildcards (*) in the filter of label, tag, worker
     */
    allowWildcards?: boolean;
    /**
     * get jobs from all workspaces (only valid if request come from the `admins` workspace)
     */
    allWorkspaces?: boolean;
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    /**
     * broad search across multiple fields (case-insensitive substring match on path, tag, schedule path, trigger kind, label)
     */
    broadFilter?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    completedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    completedBefore?: string;
    /**
     * filter on created after (exclusive) timestamp
     */
    createdAfter?: string;
    /**
     * filter on jobs created after X for jobs in the queue only
     */
    createdAfterQueue?: string;
    /**
     * filter on created before (inclusive) timestamp
     */
    createdBefore?: string;
    /**
     * filter on jobs created before X for jobs in the queue only
     */
    createdBeforeQueue?: string;
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * has null parent
     */
    hasNullParent?: boolean;
    /**
     * is the job a flow step
     */
    isFlowStep?: boolean;
    /**
     * is not a scheduled job
     */
    isNotSchedule?: boolean;
    /**
     * is the job skipped
     */
    isSkipped?: boolean;
    /**
     * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
     */
    jobKinds?: string;
    /**
     * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
     */
    label?: string;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * filter on jobs containing those result as a json subset (@> in postgres)
     */
    result?: string;
    /**
     * filter on running jobs
     */
    running?: boolean;
    /**
     * filter on jobs scheduled_for before now (hence waitinf for a worker)
     */
    scheduledForBeforeNow?: boolean;
    /**
     * mask to filter by schedule path
     */
    schedulePath?: string;
    /**
     * mask to filter exact matching path
     */
    scriptHash?: string;
    /**
     * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
     */
    scriptPathExact?: string;
    /**
     * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
     */
    scriptPathStart?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    startedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    startedBefore?: string;
    /**
     * filter on successful jobs
     */
    success?: boolean;
    /**
     * filter on suspended jobs
     */
    suspended?: boolean;
    /**
     * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
     */
    tag?: string;
    /**
     * filter by trigger kind. Supports comma-separated list (e.g. 'schedule,webhook') and negation by prefixing all values with '!' (e.g. '!schedule,!webhook')
     */
    triggerKind?: string;
    /**
     * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
     */
    worker?: string;
    workspace: string;
};
export type ListJobsResponse = Array<Job>;
export type GetDbClockResponse = number;
export type CountJobsByTagData = {
    /**
     * Past Time horizon in seconds (when to start the count = now - horizon) (default is 3600)
     */
    horizonSecs?: number;
    /**
     * Specific workspace ID to filter results (optional)
     */
    workspaceId?: string;
};
export type CountJobsByTagResponse = Array<{
    tag: string;
    count: number;
}>;
export type GetJobData = {
    /**
     * Approval token granting read access to the job when not logged in. The token must be the one issued for this job's flow (i.e. the flow id used when generating the approval URL).
     */
    approvalToken?: string;
    id: string;
    noCode?: boolean;
    noLogs?: boolean;
    workspace: string;
};
export type GetJobResponse = Job;
export type GetRootJobIdData = {
    id: string;
    workspace: string;
};
export type GetRootJobIdResponse = string;
export type GetJobLogsData = {
    id: string;
    removeAnsiWarnings?: boolean;
    workspace: string;
};
export type GetJobLogsResponse = string;
export type GetFlowAllLogsData = {
    id: string;
    workspace: string;
};
export type GetFlowAllLogsResponse = string;
export type GetCompletedJobLogsTailData = {
    id: string;
    workspace: string;
};
export type GetCompletedJobLogsTailResponse = string;
export type GetJobArgsData = {
    id: string;
    workspace: string;
};
export type GetJobArgsResponse = unknown;
export type GetStartedAtByIdsData = {
    /**
     * ids
     */
    requestBody: Array<(string)>;
    workspace: string;
};
export type GetStartedAtByIdsResponse = Array<(string)>;
export type GetJobUpdatesData = {
    getProgress?: boolean;
    id: string;
    logOffset?: number;
    noLogs?: boolean;
    running?: boolean;
    streamOffset?: number;
    workspace: string;
};
export type GetJobUpdatesResponse = {
    running?: boolean;
    completed?: boolean;
    new_logs?: string;
    log_offset?: number;
    mem_peak?: number;
    progress?: number;
    stream_offset?: number;
    new_result_stream?: string;
    flow_status?: FlowStatus;
    code_flow_status?: WorkflowStatus;
};
export type GetJobUpdatesSseData = {
    fast?: boolean;
    getProgress?: boolean;
    id: string;
    logOffset?: number;
    noLogs?: boolean;
    onlyResult?: boolean;
    running?: boolean;
    streamOffset?: number;
    workspace: string;
};
export type GetJobUpdatesSseResponse = string;
export type GetLogFileFromStoreData = {
    path: string;
    workspace: string;
};
export type GetLogFileFromStoreResponse = string;
export type GetFlowDebugInfoData = {
    id: string;
    workspace: string;
};
export type GetFlowDebugInfoResponse = unknown;
export type GetCompletedJobData = {
    id: string;
    workspace: string;
};
export type GetCompletedJobResponse = CompletedJob;
export type GetCompletedJobResultData = {
    approver?: string;
    id: string;
    resumeId?: number;
    secret?: string;
    suspendedJob?: string;
    workspace: string;
};
export type GetCompletedJobResultResponse = unknown;
export type GetCompletedJobResultMaybeData = {
    getStarted?: boolean;
    id: string;
    workspace: string;
};
export type GetCompletedJobResultMaybeResponse = {
    completed: boolean;
    result: unknown;
    success?: boolean;
    started?: boolean;
};
export type GetCompletedJobTimingData = {
    id: string;
    workspace: string;
};
export type GetCompletedJobTimingResponse = {
    created_at: string;
    started_at?: string;
    duration_ms?: number;
};
export type DeleteCompletedJobData = {
    id: string;
    workspace: string;
};
export type DeleteCompletedJobResponse = CompletedJob;
export type CancelQueuedJobData = {
    id: string;
    /**
     * reason
     */
    requestBody: {
        reason?: string;
    };
    workspace: string;
};
export type CancelQueuedJobResponse = string;
export type CancelPersistentQueuedJobsData = {
    path: string;
    /**
     * reason
     */
    requestBody: {
        reason?: string;
    };
    workspace: string;
};
export type CancelPersistentQueuedJobsResponse = string;
export type ForceCancelQueuedJobData = {
    id: string;
    /**
     * reason
     */
    requestBody: {
        reason?: string;
    };
    workspace: string;
};
export type ForceCancelQueuedJobResponse = string;
export type GetQueuePositionData = {
    scheduledFor: number;
    workspace: string;
};
export type GetQueuePositionResponse = {
    /**
     * The position in queue (1-based), null if not in queue or already running
     */
    position?: number;
};
export type GetScheduledForData = {
    id: string;
    workspace: string;
};
export type GetScheduledForResponse = number;
export type CreateJobSignatureData = {
    approver?: string;
    id: string;
    resumeId: number;
    workspace: string;
};
export type CreateJobSignatureResponse = string;
export type GetResumeUrlsData = {
    approver?: string;
    /**
     * If true, generate resume URLs for the parent flow instead of the specific step. This allows pre-approvals that can be consumed by any later suspend step in the same flow.
     */
    flowLevel?: boolean;
    id: string;
    resumeId: number;
    workspace: string;
};
export type GetResumeUrlsResponse = {
    approvalPage: string;
    resume: string;
    cancel: string;
};
export type GetSlackApprovalPayloadData = {
    approver?: string;
    cancelButtonText?: string;
    channelId: string;
    defaultArgsJson?: string;
    dynamicEnumsJson?: string;
    flowStepId: string;
    id: string;
    message?: string;
    resumeButtonText?: string;
    slackResourcePath: string;
    workspace: string;
};
export type GetSlackApprovalPayloadResponse = unknown;
export type GetTeamsApprovalPayloadData = {
    approver?: string;
    channelName: string;
    flowStepId: string;
    id: string;
    message?: string;
    /**
     * Which suspend/approval round within the step this is. Defaults to 0.
     */
    resumeId?: number;
    workspace: string;
};
export type GetTeamsApprovalPayloadResponse = unknown;
export type ResumeSuspendedData = {
    jobId: string;
    requestBody: {
        /**
         * payload to send to the resumed job
         */
        payload?: unknown;
        /**
         * approval token for unauthenticated access
         */
        approval_token?: string;
        /**
         * whether to approve (true) or cancel (false) the job
         */
        approved?: boolean;
    };
    workspace: string;
};
export type ResumeSuspendedResponse = string;
export type GetApprovalInfoData = {
    jobId: string;
    /**
     * approval token for unauthenticated access
     */
    token?: string;
    workspace: string;
};
export type GetApprovalInfoResponse = {
    flow_id: string;
    /**
     * form schema for the approval step
     */
    form_schema?: unknown;
    /**
     * description of the approval step
     */
    description?: unknown;
    approval_conditions?: {
        user_auth_required: boolean;
        user_groups_required: Array<(string)>;
        self_approval_disabled: boolean;
    };
    /**
     * whether the current user/token holder can approve
     */
    can_approve: boolean;
    /**
     * whether user authentication is required to approve
     */
    user_auth_required: boolean;
    /**
     * whether to hide the cancel button in the UI
     */
    hide_cancel?: boolean;
    approvers: Array<{
        resume_id: number;
        approver: string;
    }>;
};
export type ResumeSuspendedJobGetData = {
    approver?: string;
    id: string;
    /**
     * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
     * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
     *
     */
    payload?: string;
    resumeId: number;
    signature: string;
    workspace: string;
};
export type ResumeSuspendedJobGetResponse = string;
export type ResumeSuspendedJobPostData = {
    approver?: string;
    id: string;
    requestBody: {
        [key: string]: unknown;
    };
    resumeId: number;
    signature: string;
    workspace: string;
};
export type ResumeSuspendedJobPostResponse = string;
export type SetFlowUserStateData = {
    id: string;
    key: string;
    /**
     * new value
     */
    requestBody: unknown;
    workspace: string;
};
export type SetFlowUserStateResponse = string;
export type GetFlowUserStateData = {
    id: string;
    key: string;
    workspace: string;
};
export type GetFlowUserStateResponse = unknown;
export type ResumeSuspendedFlowAsOwnerData = {
    id: string;
    requestBody: {
        [key: string]: unknown;
    };
    workspace: string;
};
export type ResumeSuspendedFlowAsOwnerResponse = string;
export type CancelSuspendedJobGetData = {
    approver?: string;
    id: string;
    resumeId: number;
    signature: string;
    workspace: string;
};
export type CancelSuspendedJobGetResponse = string;
export type CancelSuspendedJobPostData = {
    approver?: string;
    id: string;
    requestBody: {
        [key: string]: unknown;
    };
    resumeId: number;
    signature: string;
    workspace: string;
};
export type CancelSuspendedJobPostResponse = string;
export type GetSuspendedJobFlowData = {
    approver?: string;
    id: string;
    resumeId: number;
    signature: string;
    workspace: string;
};
export type GetSuspendedJobFlowResponse = {
    job: Job;
    approvers: Array<{
        resume_id: number;
        approver: string;
    }>;
};
export type ListExtendedJobsData = {
    /**
     * allow wildcards (*) in the filter of label, tag, worker
     */
    allowWildcards?: boolean;
    /**
     * get jobs from all workspaces (only valid if request come from the `admins` workspace)
     */
    allWorkspaces?: boolean;
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    completedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    completedBefore?: string;
    concurrencyKey?: string;
    /**
     * filter on jobs created after X for jobs in the queue only
     */
    createdAfterQueue?: string;
    /**
     * filter on jobs created before X for jobs in the queue only
     */
    createdBeforeQueue?: string;
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * has null parent
     */
    hasNullParent?: boolean;
    /**
     * is the job a flow step
     */
    isFlowStep?: boolean;
    /**
     * is not a scheduled job
     */
    isNotSchedule?: boolean;
    /**
     * is the job skipped
     */
    isSkipped?: boolean;
    /**
     * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
     */
    jobKinds?: string;
    /**
     * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * The parent job that is at the origin and responsible for the execution of this script if any
     */
    parentJob?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * filter on jobs containing those result as a json subset (@> in postgres)
     */
    result?: string;
    rowLimit?: number;
    /**
     * filter on running jobs
     */
    running?: boolean;
    /**
     * filter on jobs scheduled_for before now (hence waitinf for a worker)
     */
    scheduledForBeforeNow?: boolean;
    /**
     * mask to filter by schedule path
     */
    schedulePath?: string;
    /**
     * mask to filter exact matching path
     */
    scriptHash?: string;
    /**
     * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
     */
    scriptPathExact?: string;
    /**
     * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
     */
    scriptPathStart?: string;
    /**
     * filter on started after (exclusive) timestamp
     */
    startedAfter?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    startedBefore?: string;
    /**
     * filter on successful jobs
     */
    success?: boolean;
    /**
     * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
     */
    tag?: string;
    /**
     * filter by trigger kind. Supports comma-separated list (e.g. 'schedule,webhook') and negation by prefixing all values with '!' (e.g. '!schedule,!webhook')
     */
    triggerKind?: string;
    workspace: string;
};
export type ListExtendedJobsResponse = ExtendedJobs;
export type CreateBpmnFlowData = {
    /**
     * BPMN flow to create
     */
    requestBody: NewBpmnFlow;
    workspace: string;
};
export type CreateBpmnFlowResponse = BpmnDeployResult;
export type UpdateBpmnFlowData = {
    path: string;
    /**
     * BPMN flow to update
     */
    requestBody: NewBpmnFlow;
    workspace: string;
};
export type UpdateBpmnFlowResponse = BpmnDeployResult;
export type GetBpmnFlowByPathData = {
    path: string;
    workspace: string;
};
export type GetBpmnFlowByPathResponse = BpmnFlow;
export type GetBpmnFlowByPathWithDraftData = {
    path: string;
    workspace: string;
};
export type GetBpmnFlowByPathWithDraftResponse = BpmnFlowWithDraft;
export type ExistsBpmnFlowByPathData = {
    path: string;
    workspace: string;
};
export type ExistsBpmnFlowByPathResponse = boolean;
export type ListBpmnFlowsData = {
    /**
     * Filter by the user who last edited the flow
     */
    editedBy?: string;
    includeDraftOnly?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * mask to filter exact matching path
     */
    pathExact?: string;
    /**
     * mask to filter matching starting path
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    showArchived?: boolean;
    /**
     * (default false)
     * show only the starred items
     *
     */
    starredOnly?: boolean;
    /**
     * Return NULL for description to reduce payload size
     */
    withoutDescription?: boolean;
    workspace: string;
};
export type ListBpmnFlowsResponse = Array<ListableBpmnFlow>;
export type ListSearchBpmnFlowData = {
    workspace: string;
};
export type ListSearchBpmnFlowResponse = Array<{
    path: string;
    /**
     * A projection of the flow's BPMN document — element
     * id/name plus the orvanta:scriptPath / scriptHash /
     * decisionRef extension values — never the raw
     * bpmn_xml, which is dominated by namespace
     * declarations and bpmndi: diagram-interchange
     * coordinates that would swamp client-side fuzzy
     * search scoring.
     *
     */
    value: {
        process: SearchBpmnNode;
        elements: Array<SearchBpmnNode>;
    };
}>;
export type ListBpmnPathsData = {
    workspace: string;
};
export type ListBpmnPathsResponse = Array<(string)>;
export type GetBpmnFlowHistoryData = {
    path: string;
    workspace: string;
};
export type GetBpmnFlowHistoryResponse = Array<BpmnFlowVersion>;
export type GetBpmnFlowVersionData = {
    path: string;
    version: number;
    workspace: string;
};
export type GetBpmnFlowVersionResponse = BpmnFlow;
export type ArchiveBpmnFlowByPathData = {
    path: string;
    /**
     * archive BPMN flow
     */
    requestBody: {
        archived?: boolean;
    };
    workspace: string;
};
export type ArchiveBpmnFlowByPathResponse = string;
export type DeleteBpmnFlowByPathData = {
    path: string;
    workspace: string;
};
export type DeleteBpmnFlowByPathResponse = string;
export type SeedPolyglotBpmnData = {
    workspace: string;
};
export type SeedPolyglotBpmnResponse = PolyglotBpmnSeedResult;
export type ListBpmnDelegateBindingsData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListBpmnDelegateBindingsResponse = Array<ListedBpmnDelegateBinding>;
export type GetBpmnDelegateBindingData = {
    path: string;
    workspace: string;
};
export type GetBpmnDelegateBindingResponse = BpmnDelegateBinding;
export type CreateBpmnDelegateBindingData = {
    requestBody: NewBpmnDelegateBinding;
    workspace: string;
};
export type CreateBpmnDelegateBindingResponse = string;
export type UpdateBpmnDelegateBindingData = {
    path: string;
    requestBody: NewBpmnDelegateBinding;
    workspace: string;
};
export type UpdateBpmnDelegateBindingResponse = string;
export type DeleteBpmnDelegateBindingData = {
    path: string;
    workspace: string;
};
export type DeleteBpmnDelegateBindingResponse = string;
export type ListUnboundBpmnDelegatesData = {
    workspace: string;
};
export type ListUnboundBpmnDelegatesResponse = Array<UnboundDelegateChecklistEntry>;
export type ImportBpmnDelegateBindingsData = {
    requestBody: Array<NewBpmnDelegateBinding>;
    workspace: string;
};
export type ImportBpmnDelegateBindingsResponse = ImportDelegateBindingsResult;
export type StartBpmnInstanceData = {
    path: string;
    /**
     * initial process variables
     */
    requestBody: StartBpmnInstance;
    workspace: string;
};
export type StartBpmnInstanceResponse = string;
export type PreviewBpmnInstanceData = {
    /**
     * inline BPMN XML plus initial process variables
     */
    requestBody: PreviewBpmnInstance;
    workspace: string;
};
export type PreviewBpmnInstanceResponse = string;
export type ListBpmnInstancesData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListBpmnInstancesResponse = Array<BpmnInstanceSummary>;
export type ListPendingBpmnUserTasksData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListPendingBpmnUserTasksResponse = Array<PendingUserTask>;
export type CompleteBpmnUserTaskData = {
    /**
     * the process instance id
     */
    id: string;
    requestBody: {
        [key: string]: unknown;
    };
    /**
     * the `<userTask>` element id
     */
    userTaskId: string;
    workspace: string;
};
export type CompleteBpmnUserTaskResponse = string;
export type GetBpmnInstanceData = {
    id: string;
    workspace: string;
};
export type GetBpmnInstanceResponse = BpmnInstanceDetail;
export type GetBpmnInstanceStatusData = {
    id: string;
    workspace: string;
};
export type GetBpmnInstanceStatusResponse = ProcessInstanceStatus;
export type CancelBpmnInstanceData = {
    id: string;
    /**
     * cancel reason
     */
    requestBody: CancelBpmnInstance;
    workspace: string;
};
export type CancelBpmnInstanceResponse = string;
export type ListBpmnIncidentsData = {
    id: string;
    workspace: string;
};
export type ListBpmnIncidentsResponse = Array<BpmnIncident>;
export type RetryBpmnIncidentData = {
    id: string;
    /**
     * the failed child job id identifying the incident to retry (Incident.job)
     */
    jobId: string;
    workspace: string;
};
export type RetryBpmnIncidentResponse = string;
export type GetBpmnVersionRollupData = {
    /**
     * Set false to return counts only and skip every per-version migratability check. `migratable_to_latest` then comes back null with `check_error` saying so, never false.
     */
    check?: boolean;
    workspace: string;
};
export type GetBpmnVersionRollupResponse = BpmnVersionRollup;
export type GetBpmnFlowVersionRollupData = {
    check?: boolean;
    path: string;
    workspace: string;
};
export type GetBpmnFlowVersionRollupResponse = BpmnVersionRollup;
export type CheckBpmnVersionPairData = {
    fromVersion: number;
    path: string;
    toVersion: number;
    workspace: string;
};
export type CheckBpmnVersionPairResponse = BpmnMigrationCheck;
export type CheckBpmnInstanceMigrationData = {
    id: string;
    targetVersion: number;
    workspace: string;
};
export type CheckBpmnInstanceMigrationResponse = BpmnMigrationCheck;
export type PlanBpmnVersionPairMigrationData = {
    path: string;
    requestBody: {
        from_version: number;
        to_version: number;
        mapping?: BpmnMigrationMapping;
    };
    workspace: string;
};
export type PlanBpmnVersionPairMigrationResponse = BpmnMigrationPlanCheck;
export type PlanBpmnInstanceMigrationData = {
    id: string;
    requestBody: {
        target_version: number;
        mapping?: BpmnMigrationMapping;
    };
    workspace: string;
};
export type PlanBpmnInstanceMigrationResponse = BpmnMigrationPlanCheck;
export type MigrateBpmnInstanceData = {
    id: string;
    requestBody: {
        target_version: number;
        /**
         * validate and report, write nothing
         */
        dry_run?: boolean;
    };
    workspace: string;
};
export type MigrateBpmnInstanceResponse = BpmnMigrationResult;
export type BulkMigrateBpmnInstancesData = {
    requestBody: {
        from_version: number;
        target_version: number;
        dry_run?: boolean;
    };
    workspace: string;
};
export type BulkMigrateBpmnInstancesResponse = BpmnMigrationResult;
export type CreateDmnDecisionData = {
    /**
     * DMN decision to create
     */
    requestBody: NewDmnDecision;
    workspace: string;
};
export type CreateDmnDecisionResponse = string;
export type UpdateDmnDecisionData = {
    path: string;
    /**
     * DMN decision to update
     */
    requestBody: NewDmnDecision;
    workspace: string;
};
export type UpdateDmnDecisionResponse = string;
export type GetDmnDecisionByPathData = {
    path: string;
    workspace: string;
};
export type GetDmnDecisionByPathResponse = DmnDecision;
export type GetDmnDecisionByPathWithDraftData = {
    path: string;
    workspace: string;
};
export type GetDmnDecisionByPathWithDraftResponse = DmnDecisionWithDraft;
export type ExistsDmnDecisionByPathData = {
    path: string;
    workspace: string;
};
export type ExistsDmnDecisionByPathResponse = boolean;
export type ListDmnDecisionsData = {
    /**
     * Filter by the user who last edited the decision
     */
    editedBy?: string;
    includeDraftOnly?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * mask to filter exact matching path
     */
    pathExact?: string;
    /**
     * mask to filter matching starting path
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    showArchived?: boolean;
    /**
     * Return NULL for description to reduce payload size
     */
    withoutDescription?: boolean;
    workspace: string;
};
export type ListDmnDecisionsResponse = Array<ListableDmnDecision>;
export type GetDmnDecisionHistoryData = {
    path: string;
    workspace: string;
};
export type GetDmnDecisionHistoryResponse = Array<DmnDecisionVersion>;
export type ArchiveDmnDecisionByPathData = {
    path: string;
    /**
     * archive DMN decision
     */
    requestBody: {
        archived?: boolean;
    };
    workspace: string;
};
export type ArchiveDmnDecisionByPathResponse = string;
export type DeleteDmnDecisionByPathData = {
    path: string;
    workspace: string;
};
export type DeleteDmnDecisionByPathResponse = string;
export type EvaluateDmnDecisionData = {
    /**
     * decision reference (saved path or inline XML) plus input values
     */
    requestBody: EvaluateRequest;
    workspace: string;
};
export type EvaluateDmnDecisionResponse = EvaluateResponse;
export type EvaluateDmnDecisionServiceData = {
    /**
     * document reference (saved path or inline XML), the decision service id, and input values
     */
    requestBody: EvaluateServiceRequest;
    workspace: string;
};
export type EvaluateDmnDecisionServiceResponse = EvaluateServiceResponse;
export type ListFlowConversationsData = {
    /**
     * filter conversations by flow path
     */
    flowPath?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListFlowConversationsResponse = Array<FlowConversation>;
export type DeleteFlowConversationData = {
    /**
     * conversation id
     */
    conversationId: string;
    workspace: string;
};
export type DeleteFlowConversationResponse = string;
export type ListConversationMessagesData = {
    /**
     * Message sequence cursor to fetch only the messages after that cursor
     */
    afterSeq?: number;
    /**
     * conversation id
     */
    conversationId: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListConversationMessagesResponse = Array<FlowConversationMessage>;
export type ListPathAutocompletePathsData = {
    workspace: string;
};
export type ListPathAutocompletePathsResponse = {
    paths: Array<(string)>;
};
export type ListRawAppsData = {
    /**
     * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
     */
    createdBy?: string;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * order by desc order (default true)
     */
    orderDesc?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * mask to filter exact matching path
     */
    pathExact?: string;
    /**
     * mask to filter matching starting path
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * (default false)
     * show only the starred items
     *
     */
    starredOnly?: boolean;
    workspace: string;
};
export type ListRawAppsResponse = Array<ListableRawApp>;
export type ResumeSuspendedTriggerJobsData = {
    /**
     * Optional list of job IDs to reassign
     */
    requestBody?: {
        /**
         * Optional list of specific job UUIDs to reassign. If not provided, all suspended jobs for the trigger will be reassigned.
         */
        job_ids?: Array<(string)>;
    };
    /**
     * The kind of trigger
     */
    triggerKind: JobTriggerKind;
    /**
     * The path of the trigger (can contain forward slashes)
     */
    triggerPath: string;
    workspace: string;
};
export type ResumeSuspendedTriggerJobsResponse = string;
export type CancelSuspendedTriggerJobsData = {
    /**
     * Optional list of job IDs to cancel
     */
    requestBody?: {
        /**
         * Optional list of specific job UUIDs to cancel. If not provided, all suspended jobs for the trigger will be canceled.
         */
        job_ids?: Array<(string)>;
    };
    /**
     * The kind of trigger
     */
    triggerKind: JobTriggerKind;
    /**
     * The path of the trigger (can contain forward slashes)
     */
    triggerPath: string;
    workspace: string;
};
export type CancelSuspendedTriggerJobsResponse = string;
export type PreviewScheduleData = {
    /**
     * schedule
     */
    requestBody: {
        schedule: string;
        timezone: string;
        cron_version?: string;
        /**
         * Defaults to true (6-field cron, matching createSchedule). Pass false to validate under the same rule the BPMN timer-start deploy-time reconciler uses (seconds optional, so 5- and 6-field expressions both validate).
         */
        seconds_required?: boolean;
    };
};
export type PreviewScheduleResponse = Array<(string)>;
export type CreateScheduleData = {
    /**
     * new schedule
     */
    requestBody: NewSchedule;
    workspace: string;
};
export type CreateScheduleResponse = string;
export type UpdateScheduleData = {
    path: string;
    /**
     * updated schedule
     */
    requestBody: EditSchedule;
    workspace: string;
};
export type UpdateScheduleResponse = string;
export type SetScheduleEnabledData = {
    path: string;
    /**
     * updated schedule enable
     */
    requestBody: {
        enabled: boolean;
        /**
         * Bypass the parent-state conflict warning when enabling a schedule in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetScheduleEnabledResponse = string;
export type DeleteScheduleData = {
    path: string;
    workspace: string;
};
export type DeleteScheduleResponse = string;
export type GetScheduleData = {
    path: string;
    workspace: string;
};
export type GetScheduleResponse = Schedule;
export type ExistsScheduleData = {
    path: string;
    workspace: string;
};
export type ExistsScheduleResponse = boolean;
export type ListSchedulesData = {
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    /**
     * broad search across multiple fields (case-insensitive substring match)
     */
    broadFilter?: string;
    /**
     * pattern match filter for description field (case-insensitive)
     */
    description?: string;
    /**
     * filter schedules by whether they target a flow
     */
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path (script path)
     */
    path?: string;
    /**
     * filter schedules by path prefix
     */
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    /**
     * exact match on the schedule's path
     */
    schedulePath?: string;
    /**
     * pattern match filter for summary field (case-insensitive)
     */
    summary?: string;
    workspace: string;
};
export type ListSchedulesResponse = Array<Schedule>;
export type ListSchedulesWithJobsData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListSchedulesWithJobsResponse = Array<ScheduleWJobs>;
export type SetDefaultErrorOrRecoveryHandlerData = {
    /**
     * Handler description
     */
    requestBody: {
        handler_type: 'error' | 'recovery' | 'success';
        override_existing: boolean;
        path?: string;
        extra_args?: {
            [key: string]: unknown;
        };
        number_of_occurence?: number;
        number_of_occurence_exact?: boolean;
        workspace_handler_muted?: boolean;
    };
    workspace: string;
};
export type SetDefaultErrorOrRecoveryHandlerResponse = unknown;
export type GenerateOpenapiSpecData = {
    /**
     * openapi spec info and url
     */
    requestBody?: GenerateOpenapiSpec;
    workspace: string;
};
export type GenerateOpenapiSpecResponse = string;
export type DownloadOpenapiSpecData = {
    /**
     * openapi spec info and url
     */
    requestBody?: GenerateOpenapiSpec;
    workspace: string;
};
export type DownloadOpenapiSpecResponse = (Blob | File);
export type CreateHttpTriggersData = {
    /**
     * new http trigger
     */
    requestBody: Array<NewHttpTrigger>;
    workspace: string;
};
export type CreateHttpTriggersResponse = string;
export type CreateHttpTriggerData = {
    /**
     * new http trigger
     */
    requestBody: NewHttpTrigger;
    workspace: string;
};
export type CreateHttpTriggerResponse = string;
export type UpdateHttpTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditHttpTrigger;
    workspace: string;
};
export type UpdateHttpTriggerResponse = string;
export type DeleteHttpTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteHttpTriggerResponse = string;
export type GetHttpTriggerData = {
    path: string;
    workspace: string;
};
export type GetHttpTriggerResponse = HttpTrigger;
export type ListHttpTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListHttpTriggersResponse = Array<HttpTrigger>;
export type ExistsHttpTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsHttpTriggerResponse = boolean;
export type ExistsRouteData = {
    /**
     * route exists request
     */
    requestBody: {
        route_path: string;
        http_method: HttpMethod;
        trigger_path?: string;
        workspaced_route?: boolean;
    };
    workspace: string;
};
export type ExistsRouteResponse = boolean;
export type SetHttpTriggerModeData = {
    path: string;
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetHttpTriggerModeResponse = string;
export type CreateWebsocketTriggerData = {
    /**
     * new websocket trigger
     */
    requestBody: NewWebsocketTrigger;
    workspace: string;
};
export type CreateWebsocketTriggerResponse = string;
export type UpdateWebsocketTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditWebsocketTrigger;
    workspace: string;
};
export type UpdateWebsocketTriggerResponse = string;
export type DeleteWebsocketTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteWebsocketTriggerResponse = string;
export type GetWebsocketTriggerData = {
    path: string;
    workspace: string;
};
export type GetWebsocketTriggerResponse = WebsocketTrigger;
export type ListWebsocketTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListWebsocketTriggersResponse = Array<WebsocketTrigger>;
export type ExistsWebsocketTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsWebsocketTriggerResponse = boolean;
export type SetWebsocketTriggerModeData = {
    path: string;
    /**
     * updated websocket trigger enable
     */
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetWebsocketTriggerModeResponse = string;
export type TestWebsocketConnectionData = {
    /**
     * test websocket connection
     */
    requestBody: {
        url: string;
        url_runnable_args?: ScriptArgs;
        can_return_message: boolean;
    };
    workspace: string;
};
export type TestWebsocketConnectionResponse = string;
export type CreateKafkaTriggerData = {
    /**
     * new kafka trigger
     */
    requestBody: NewKafkaTrigger;
    workspace: string;
};
export type CreateKafkaTriggerResponse = string;
export type UpdateKafkaTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditKafkaTrigger;
    workspace: string;
};
export type UpdateKafkaTriggerResponse = string;
export type DeleteKafkaTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteKafkaTriggerResponse = string;
export type GetKafkaTriggerData = {
    path: string;
    workspace: string;
};
export type GetKafkaTriggerResponse = KafkaTrigger;
export type ListKafkaTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListKafkaTriggersResponse = Array<KafkaTrigger>;
export type ExistsKafkaTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsKafkaTriggerResponse = boolean;
export type SetKafkaTriggerModeData = {
    path: string;
    /**
     * updated kafka trigger enable
     */
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetKafkaTriggerModeResponse = string;
export type TestKafkaConnectionData = {
    /**
     * test kafka connection
     */
    requestBody: {
        connection: {
            [key: string]: unknown;
        };
    };
    workspace: string;
};
export type TestKafkaConnectionResponse = string;
export type ResetKafkaOffsetsData = {
    path: string;
    workspace: string;
};
export type ResetKafkaOffsetsResponse = unknown;
export type CommitKafkaOffsetsData = {
    path: string;
    /**
     * offsets to commit
     */
    requestBody: {
        topic: string;
        partition: number;
        offset: number;
    };
    workspace: string;
};
export type CommitKafkaOffsetsResponse = unknown;
export type CreateNatsTriggerData = {
    /**
     * new nats trigger
     */
    requestBody: NewNatsTrigger;
    workspace: string;
};
export type CreateNatsTriggerResponse = string;
export type UpdateNatsTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditNatsTrigger;
    workspace: string;
};
export type UpdateNatsTriggerResponse = string;
export type DeleteNatsTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteNatsTriggerResponse = string;
export type GetNatsTriggerData = {
    path: string;
    workspace: string;
};
export type GetNatsTriggerResponse = NatsTrigger;
export type ListNatsTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListNatsTriggersResponse = Array<NatsTrigger>;
export type ExistsNatsTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsNatsTriggerResponse = boolean;
export type SetNatsTriggerModeData = {
    path: string;
    /**
     * updated nats trigger enable
     */
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetNatsTriggerModeResponse = string;
export type TestNatsConnectionData = {
    /**
     * test nats connection
     */
    requestBody: {
        connection: {
            [key: string]: unknown;
        };
    };
    workspace: string;
};
export type TestNatsConnectionResponse = string;
export type CreateSqsTriggerData = {
    /**
     * new sqs trigger
     */
    requestBody: NewSqsTrigger;
    workspace: string;
};
export type CreateSqsTriggerResponse = string;
export type UpdateSqsTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditSqsTrigger;
    workspace: string;
};
export type UpdateSqsTriggerResponse = string;
export type DeleteSqsTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteSqsTriggerResponse = string;
export type GetSqsTriggerData = {
    path: string;
    workspace: string;
};
export type GetSqsTriggerResponse = SqsTrigger;
export type ListSqsTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListSqsTriggersResponse = Array<SqsTrigger>;
export type ExistsSqsTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsSqsTriggerResponse = boolean;
export type SetSqsTriggerModeData = {
    path: string;
    /**
     * updated sqs trigger enable
     */
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetSqsTriggerModeResponse = string;
export type TestSqsConnectionData = {
    /**
     * test sqs connection
     */
    requestBody: {
        connection: {
            [key: string]: unknown;
        };
    };
    workspace: string;
};
export type TestSqsConnectionResponse = string;
export type ListNativeTriggerServicesData = {
    workspace: string;
};
export type ListNativeTriggerServicesResponse = Array<WorkspaceIntegrations>;
export type CheckIfNativeTriggersServiceExistsData = {
    serviceName: NativeServiceName;
    workspace: string;
};
export type CheckIfNativeTriggersServiceExistsResponse = boolean;
export type CreateNativeTriggerServiceData = {
    /**
     * new native trigger service
     */
    requestBody: WorkspaceOAuthConfig;
    serviceName: NativeServiceName;
    workspace: string;
};
export type CreateNativeTriggerServiceResponse = string;
export type GenerateNativeTriggerServiceConnectUrlData = {
    /**
     * redirect_uri
     */
    requestBody: RedirectUri;
    serviceName: NativeServiceName;
    workspace: string;
};
export type GenerateNativeTriggerServiceConnectUrlResponse = string;
export type CheckInstanceSharingAvailableData = {
    serviceName: NativeServiceName;
    workspace: string;
};
export type CheckInstanceSharingAvailableResponse = boolean;
export type GenerateInstanceConnectUrlData = {
    /**
     * redirect_uri
     */
    requestBody: RedirectUri;
    serviceName: NativeServiceName;
    workspace: string;
};
export type GenerateInstanceConnectUrlResponse = string;
export type DeleteNativeTriggerServiceData = {
    serviceName: NativeServiceName;
    workspace: string;
};
export type DeleteNativeTriggerServiceResponse = string;
export type NativeTriggerServiceCallbackData = {
    /**
     * OAuth callback data
     */
    requestBody: {
        code: string;
        state: string;
        redirect_uri: string;
        resource_path?: string;
    };
    serviceName: NativeServiceName;
    workspace: string;
};
export type NativeTriggerServiceCallbackResponse = string;
export type CreateNativeTriggerData = {
    /**
     * new native trigger configuration
     */
    requestBody: NativeTriggerData;
    serviceName: NativeServiceName;
    workspace: string;
};
export type CreateNativeTriggerResponse = CreateTriggerResponse;
export type UpdateNativeTriggerData = {
    /**
     * The external ID of the trigger from the external service
     */
    externalId: string;
    /**
     * updated native trigger configuration
     */
    requestBody: NativeTriggerData;
    serviceName: NativeServiceName;
    workspace: string;
};
export type UpdateNativeTriggerResponse = string;
export type GetNativeTriggerData = {
    /**
     * The external ID of the trigger from the external service
     */
    externalId: string;
    serviceName: NativeServiceName;
    workspace: string;
};
export type GetNativeTriggerResponse = NativeTriggerWithExternal;
export type DeleteNativeTriggerData = {
    /**
     * The external ID of the trigger from the external service
     */
    externalId: string;
    serviceName: NativeServiceName;
    workspace: string;
};
export type DeleteNativeTriggerResponse = string;
export type ListNativeTriggersData = {
    /**
     * filter by is_flow
     */
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by script path
     */
    path?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    serviceName: NativeServiceName;
    workspace: string;
};
export type ListNativeTriggersResponse = Array<NativeTrigger>;
export type ExistsNativeTriggerData = {
    /**
     * The external ID of the trigger from the external service
     */
    externalId: string;
    serviceName: NativeServiceName;
    workspace: string;
};
export type ExistsNativeTriggerResponse = boolean;
export type SyncNativeTriggersData = {
    serviceName: NativeServiceName;
    workspace: string;
};
export type SyncNativeTriggersResponse = unknown;
export type ListNextCloudEventsData = {
    workspace: string;
};
export type ListNextCloudEventsResponse = Array<NextCloudEventType>;
export type ListGoogleCalendarsData = {
    workspace: string;
};
export type ListGoogleCalendarsResponse = Array<GoogleCalendarEntry>;
export type ListGoogleDriveFilesData = {
    /**
     * token for next page of results
     */
    pageToken?: string;
    /**
     * folder ID to list children of
     */
    parentId?: string;
    /**
     * search query to filter files by name
     */
    q?: string;
    /**
     * if true, list files shared with the user
     */
    sharedWithMe?: boolean;
    workspace: string;
};
export type ListGoogleDriveFilesResponse = GoogleDriveFilesResponse;
export type ListGoogleSharedDrivesData = {
    workspace: string;
};
export type ListGoogleSharedDrivesResponse = Array<SharedDriveEntry>;
export type ListGithubReposData = {
    workspace: string;
};
export type ListGithubReposResponse = Array<GithubRepoEntry>;
export type NativeTriggerWebhookData = {
    /**
     * The internal database ID of the trigger
     */
    internalId: number;
    /**
     * webhook payload from external service
     */
    requestBody?: {
        [key: string]: unknown;
    };
    serviceName: NativeServiceName;
    workspaceId: string;
};
export type NativeTriggerWebhookResponse = string;
export type CreateMqttTriggerData = {
    /**
     * new mqtt trigger
     */
    requestBody: NewMqttTrigger;
    workspace: string;
};
export type CreateMqttTriggerResponse = string;
export type UpdateMqttTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditMqttTrigger;
    workspace: string;
};
export type UpdateMqttTriggerResponse = string;
export type DeleteMqttTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteMqttTriggerResponse = string;
export type GetMqttTriggerData = {
    path: string;
    workspace: string;
};
export type GetMqttTriggerResponse = MqttTrigger;
export type ListMqttTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListMqttTriggersResponse = Array<MqttTrigger>;
export type ExistsMqttTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsMqttTriggerResponse = boolean;
export type SetMqttTriggerModeData = {
    path: string;
    /**
     * updated mqtt trigger enable
     */
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetMqttTriggerModeResponse = string;
export type TestMqttConnectionData = {
    /**
     * test mqtt connection
     */
    requestBody: {
        connection: {
            [key: string]: unknown;
        };
    };
    workspace: string;
};
export type TestMqttConnectionResponse = string;
export type CreateGcpTriggerData = {
    /**
     * new gcp trigger
     */
    requestBody: GcpTriggerData;
    workspace: string;
};
export type CreateGcpTriggerResponse = string;
export type UpdateGcpTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: GcpTriggerData;
    workspace: string;
};
export type UpdateGcpTriggerResponse = string;
export type DeleteGcpTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteGcpTriggerResponse = string;
export type GetGcpTriggerData = {
    path: string;
    workspace: string;
};
export type GetGcpTriggerResponse = GcpTrigger;
export type ListGcpTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListGcpTriggersResponse = Array<GcpTrigger>;
export type ExistsGcpTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsGcpTriggerResponse = boolean;
export type SetGcpTriggerModeData = {
    path: string;
    /**
     * updated gcp trigger enable
     */
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetGcpTriggerModeResponse = string;
export type TestGcpConnectionData = {
    /**
     * test gcp connection
     */
    requestBody: {
        connection: {
            [key: string]: unknown;
        };
    };
    workspace: string;
};
export type TestGcpConnectionResponse = string;
export type DeleteGcpSubscriptionData = {
    path: string;
    /**
     * args to delete subscription from google cloud
     */
    requestBody: DeleteGcpSubscription;
    workspace: string;
};
export type DeleteGcpSubscriptionResponse = string;
export type ListGoogleTopicsData = {
    path: string;
    workspace: string;
};
export type ListGoogleTopicsResponse = Array<(string)>;
export type ListAllTgoogleTopicSubscriptionsData = {
    path: string;
    /**
     * args to get subscription's topic from google cloud
     */
    requestBody: GetAllTopicSubscription;
    workspace: string;
};
export type ListAllTgoogleTopicSubscriptionsResponse = Array<(string)>;
export type CreateAzureTriggerData = {
    requestBody: AzureTriggerData;
    workspace: string;
};
export type CreateAzureTriggerResponse = string;
export type UpdateAzureTriggerData = {
    path: string;
    requestBody: AzureTriggerData;
    workspace: string;
};
export type UpdateAzureTriggerResponse = string;
export type DeleteAzureTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteAzureTriggerResponse = string;
export type GetAzureTriggerData = {
    path: string;
    workspace: string;
};
export type GetAzureTriggerResponse = AzureTrigger;
export type ListAzureTriggersData = {
    isFlow?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by exact path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListAzureTriggersResponse = Array<AzureTrigger>;
export type ExistsAzureTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsAzureTriggerResponse = boolean;
export type SetAzureTriggerModeData = {
    path: string;
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetAzureTriggerModeResponse = string;
export type TestAzureConnectionData = {
    requestBody: TestAzureConnection;
    workspace: string;
};
export type TestAzureConnectionResponse = string;
export type ListAzureNamespaceTopicsData = {
    path: string;
    requestBody: AzureListTopics;
    workspace: string;
};
export type ListAzureNamespaceTopicsResponse = Array<{
    [key: string]: unknown;
}>;
export type ListAzureNamespaceSubscriptionsData = {
    path: string;
    requestBody: AzureListSubscriptions;
    workspace: string;
};
export type ListAzureNamespaceSubscriptionsResponse = Array<{
    [key: string]: unknown;
}>;
export type DeleteAzureSubscriptionData = {
    path: string;
    requestBody: AzureDeleteSubscription;
    workspace: string;
};
export type DeleteAzureSubscriptionResponse = string;
export type ListAzureNamespacesData = {
    path: string;
    workspace: string;
};
export type ListAzureNamespacesResponse = Array<AzureArmResource>;
export type ListAzureBasicTopicsData = {
    path: string;
    workspace: string;
};
export type ListAzureBasicTopicsResponse = Array<AzureArmResource>;
export type GetPostgresVersionData = {
    path: string;
    workspace: string;
};
export type GetPostgresVersionResponse = string;
export type IsValidPostgresConfigurationData = {
    path: string;
    workspace: string;
};
export type IsValidPostgresConfigurationResponse = boolean;
export type CreateTemplateScriptData = {
    /**
     * template script
     */
    requestBody: TemplateScript;
    workspace: string;
};
export type CreateTemplateScriptResponse = string;
export type GetTemplateScriptData = {
    id: string;
    workspace: string;
};
export type GetTemplateScriptResponse = string;
export type ListPostgresReplicationSlotData = {
    path: string;
    workspace: string;
};
export type ListPostgresReplicationSlotResponse = Array<SlotList>;
export type CreatePostgresReplicationSlotData = {
    path: string;
    /**
     * new slot for postgres
     */
    requestBody: Slot;
    workspace: string;
};
export type CreatePostgresReplicationSlotResponse = string;
export type DeletePostgresReplicationSlotData = {
    path: string;
    /**
     * replication slot of postgres
     */
    requestBody: Slot;
    workspace: string;
};
export type DeletePostgresReplicationSlotResponse = string;
export type ListPostgresPublicationData = {
    path: string;
    workspace: string;
};
export type ListPostgresPublicationResponse = Array<(string)>;
export type GetPostgresPublicationData = {
    path: string;
    /**
     * The name of the publication
     */
    publication: string;
    workspace: string;
};
export type GetPostgresPublicationResponse = PublicationData;
export type CreatePostgresPublicationData = {
    path: string;
    /**
     * The name of the publication
     */
    publication: string;
    /**
     * new publication for postgres
     */
    requestBody: PublicationData;
    workspace: string;
};
export type CreatePostgresPublicationResponse = string;
export type UpdatePostgresPublicationData = {
    path: string;
    /**
     * The name of the publication
     */
    publication: string;
    /**
     * update publication for postgres
     */
    requestBody: PublicationData;
    workspace: string;
};
export type UpdatePostgresPublicationResponse = string;
export type DeletePostgresPublicationData = {
    path: string;
    /**
     * The name of the publication
     */
    publication: string;
    workspace: string;
};
export type DeletePostgresPublicationResponse = string;
export type CreatePostgresTriggerData = {
    /**
     * new postgres trigger
     */
    requestBody: NewPostgresTrigger;
    workspace: string;
};
export type CreatePostgresTriggerResponse = string;
export type UpdatePostgresTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditPostgresTrigger;
    workspace: string;
};
export type UpdatePostgresTriggerResponse = string;
export type DeletePostgresTriggerData = {
    path: string;
    workspace: string;
};
export type DeletePostgresTriggerResponse = string;
export type GetPostgresTriggerData = {
    path: string;
    workspace: string;
};
export type GetPostgresTriggerResponse = PostgresTrigger;
export type ListPostgresTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListPostgresTriggersResponse = Array<PostgresTrigger>;
export type ExistsPostgresTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsPostgresTriggerResponse = boolean;
export type SetPostgresTriggerModeData = {
    path: string;
    /**
     * updated postgres trigger enable
     */
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetPostgresTriggerModeResponse = string;
export type TestPostgresConnectionData = {
    /**
     * test postgres connection
     */
    requestBody: {
        database: string;
    };
    workspace: string;
};
export type TestPostgresConnectionResponse = string;
export type CreateEmailTriggerData = {
    /**
     * new email trigger
     */
    requestBody: NewEmailTrigger;
    workspace: string;
};
export type CreateEmailTriggerResponse = string;
export type UpdateEmailTriggerData = {
    path: string;
    /**
     * updated trigger
     */
    requestBody: EditEmailTrigger;
    workspace: string;
};
export type UpdateEmailTriggerResponse = string;
export type DeleteEmailTriggerData = {
    path: string;
    workspace: string;
};
export type DeleteEmailTriggerResponse = string;
export type GetEmailTriggerData = {
    path: string;
    workspace: string;
};
export type GetEmailTriggerResponse = EmailTrigger;
export type ListEmailTriggersData = {
    isFlow?: boolean;
    /**
     * Filter by label
     */
    label?: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * filter by path
     */
    path?: string;
    pathStart?: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListEmailTriggersResponse = Array<EmailTrigger>;
export type ExistsEmailTriggerData = {
    path: string;
    workspace: string;
};
export type ExistsEmailTriggerResponse = boolean;
export type ExistsEmailLocalPartData = {
    /**
     * email local part exists request
     */
    requestBody: {
        local_part: string;
        workspaced_local_part?: boolean;
        trigger_path?: string;
    };
    workspace: string;
};
export type ExistsEmailLocalPartResponse = boolean;
export type SetEmailTriggerModeData = {
    path: string;
    requestBody: {
        mode: TriggerMode;
        /**
         * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
         *
         */
        force?: boolean;
    };
    workspace: string;
};
export type SetEmailTriggerModeResponse = string;
export type ListInstanceGroupsResponse = Array<InstanceGroup>;
export type ListInstanceGroupsWithWorkspacesResponse = Array<InstanceGroupWithWorkspaces>;
export type GetInstanceGroupData = {
    name: string;
};
export type GetInstanceGroupResponse = InstanceGroupWithWorkspaces;
export type CreateInstanceGroupData = {
    /**
     * create instance group
     */
    requestBody: {
        name: string;
        summary?: string;
    };
};
export type CreateInstanceGroupResponse = string;
export type UpdateInstanceGroupData = {
    name: string;
    /**
     * update instance group
     */
    requestBody: {
        new_summary: string;
        /**
         * Instance-level role for group members. 'superadmin', 'devops', 'user' or empty to clear.
         */
        instance_role?: string | null;
    };
};
export type UpdateInstanceGroupResponse = string;
export type DeleteInstanceGroupData = {
    name: string;
};
export type DeleteInstanceGroupResponse = string;
export type AddUserToInstanceGroupData = {
    name: string;
    /**
     * user to add to instance group
     */
    requestBody: {
        email: string;
    };
};
export type AddUserToInstanceGroupResponse = string;
export type RemoveUserFromInstanceGroupData = {
    name: string;
    /**
     * user to remove from instance group
     */
    requestBody: {
        email: string;
    };
};
export type RemoveUserFromInstanceGroupResponse = string;
export type ExportInstanceGroupsResponse = Array<ExportedInstanceGroup>;
export type OverwriteInstanceGroupsData = {
    /**
     * overwrite instance groups
     */
    requestBody: Array<ExportedInstanceGroup>;
};
export type OverwriteInstanceGroupsResponse = string;
export type ListGroupsData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListGroupsResponse = Array<Group>;
export type ListGroupNamesData = {
    /**
     * only list the groups the user is member of (default false)
     */
    onlyMemberOf?: boolean;
    workspace: string;
};
export type ListGroupNamesResponse = Array<(string)>;
export type CreateGroupData = {
    /**
     * create group
     */
    requestBody: {
        name: string;
        summary?: string;
    };
    workspace: string;
};
export type CreateGroupResponse = string;
export type UpdateGroupData = {
    name: string;
    /**
     * updated group
     */
    requestBody: {
        summary?: string;
    };
    workspace: string;
};
export type UpdateGroupResponse = string;
export type DeleteGroupData = {
    name: string;
    workspace: string;
};
export type DeleteGroupResponse = string;
export type GetGroupData = {
    name: string;
    workspace: string;
};
export type GetGroupResponse = Group;
export type AddUserToGroupData = {
    name: string;
    /**
     * added user to group
     */
    requestBody: {
        username?: string;
    };
    workspace: string;
};
export type AddUserToGroupResponse = string;
export type RemoveUserToGroupData = {
    name: string;
    /**
     * added user to group
     */
    requestBody: {
        username?: string;
    };
    workspace: string;
};
export type RemoveUserToGroupResponse = string;
export type GetGroupPermissionHistoryData = {
    name: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type GetGroupPermissionHistoryResponse = Array<{
    id?: number;
    changed_by?: string;
    changed_at?: string;
    change_type?: string;
    member_affected?: string | null;
}>;
export type ListFoldersData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type ListFoldersResponse = Array<Folder>;
export type ListFolderNamesData = {
    /**
     * only list the folders the user is member of (default false)
     */
    onlyMemberOf?: boolean;
    workspace: string;
};
export type ListFolderNamesResponse = Array<(string)>;
export type CreateFolderData = {
    /**
     * create folder
     */
    requestBody: {
        name: string;
        summary?: string;
        owners?: Array<(string)>;
        extra_perms?: unknown;
        default_permissioned_as?: FolderDefaultPermissionedAs;
    };
    workspace: string;
};
export type CreateFolderResponse = string;
export type UpdateFolderData = {
    name: string;
    /**
     * update folder
     */
    requestBody: {
        summary?: string;
        owners?: Array<(string)>;
        extra_perms?: unknown;
        default_permissioned_as?: FolderDefaultPermissionedAs;
    };
    workspace: string;
};
export type UpdateFolderResponse = string;
export type DeleteFolderData = {
    name: string;
    workspace: string;
};
export type DeleteFolderResponse = string;
export type GetFolderData = {
    name: string;
    workspace: string;
};
export type GetFolderResponse = Folder;
export type ExistsFolderData = {
    name: string;
    workspace: string;
};
export type ExistsFolderResponse = boolean;
export type GetFolderUsageData = {
    name: string;
    workspace: string;
};
export type GetFolderUsageResponse = {
    scripts: number;
    flows: number;
    apps: number;
    resources: number;
    variables: number;
    schedules: number;
};
export type AddOwnerToFolderData = {
    name: string;
    /**
     * owner user to folder
     */
    requestBody: {
        owner: string;
    };
    workspace: string;
};
export type AddOwnerToFolderResponse = string;
export type RemoveOwnerToFolderData = {
    name: string;
    /**
     * added owner to folder
     */
    requestBody: {
        owner: string;
        write?: boolean;
    };
    workspace: string;
};
export type RemoveOwnerToFolderResponse = string;
export type GetFolderPermissionHistoryData = {
    name: string;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workspace: string;
};
export type GetFolderPermissionHistoryResponse = Array<{
    id?: number;
    changed_by?: string;
    changed_at?: string;
    change_type?: string;
    affected?: string | null;
}>;
export type ListWorkerGroupsResponse = Array<{
    name: string;
    config: unknown;
}>;
export type ListWorkerPoolsResponse = Array<{
    name: string;
    config: unknown;
}>;
export type GetConfigData = {
    name: string;
};
export type GetConfigResponse = Configs;
export type UpdateConfigData = {
    name: string;
    /**
     * worker group
     */
    requestBody: unknown;
};
export type UpdateConfigResponse = string;
export type DeleteConfigData = {
    name: string;
};
export type DeleteConfigResponse = string;
export type ListConfigsResponse = Array<Config>;
export type ListAutoscalingEventsData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    workerGroup: string;
};
export type ListAutoscalingEventsResponse = Array<AutoscalingEvent>;
export type NativeKubernetesAutoscalingHealthcheckResponse = unknown;
export type ListAvailablePythonVersionsResponse = Array<(string)>;
export type ListAllWorkspaceDependenciesResponse = Array<{
    workspace_id: string;
    name?: string;
    language: ScriptLang;
}>;
export type ListAllDedicatedWithDepsResponse = Array<{
    workspace_id: string;
    path: string;
    language: ScriptLang;
    workspace_dep_names: Array<(string)>;
}>;
export type CreateAgentTokenData = {
    /**
     * agent token
     */
    requestBody: {
        worker_group: string;
        tags: Array<(string)>;
        exp: number;
    };
};
export type CreateAgentTokenResponse = string;
export type BlacklistAgentTokenData = {
    /**
     * token to blacklist
     */
    requestBody: {
        /**
         * The agent token to blacklist
         */
        token: string;
        /**
         * Optional expiration date for the blacklist entry
         */
        expires_at?: string;
    };
};
export type BlacklistAgentTokenResponse = unknown;
export type RemoveBlacklistAgentTokenData = {
    /**
     * token to remove from blacklist
     */
    requestBody: {
        /**
         * The agent token to remove from blacklist
         */
        token: string;
    };
};
export type RemoveBlacklistAgentTokenResponse = unknown;
export type ListBlacklistedAgentTokensData = {
    /**
     * Whether to include expired blacklisted tokens
     */
    includeExpired?: boolean;
};
export type ListBlacklistedAgentTokensResponse = Array<{
    /**
     * The blacklisted token (without prefix)
     */
    token: string;
    /**
     * When the blacklist entry expires
     */
    expires_at: string;
    /**
     * When the token was blacklisted
     */
    blacklisted_at: string;
    /**
     * Email of the user who blacklisted the token
     */
    blacklisted_by: string;
}>;
export type GetMinVersionResponse = string;
export type GetGranularAclsData = {
    kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app' | 'raw_app' | 'http_trigger' | 'websocket_trigger' | 'kafka_trigger' | 'nats_trigger' | 'postgres_trigger' | 'mqtt_trigger' | 'gcp_trigger' | 'azure_trigger' | 'sqs_trigger' | 'email_trigger' | 'volume';
    path: string;
    workspace: string;
};
export type GetGranularAclsResponse = {
    [key: string]: (boolean);
};
export type AddGranularAclsData = {
    kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app' | 'raw_app' | 'http_trigger' | 'websocket_trigger' | 'kafka_trigger' | 'nats_trigger' | 'postgres_trigger' | 'mqtt_trigger' | 'gcp_trigger' | 'azure_trigger' | 'sqs_trigger' | 'email_trigger' | 'volume';
    path: string;
    /**
     * acl to add
     */
    requestBody: {
        owner: string;
        write?: boolean;
    };
    workspace: string;
};
export type AddGranularAclsResponse = string;
export type RemoveGranularAclsData = {
    kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app' | 'raw_app' | 'http_trigger' | 'websocket_trigger' | 'kafka_trigger' | 'nats_trigger' | 'postgres_trigger' | 'mqtt_trigger' | 'gcp_trigger' | 'azure_trigger' | 'sqs_trigger' | 'email_trigger' | 'volume';
    path: string;
    /**
     * acl to add
     */
    requestBody: {
        owner: string;
    };
    workspace: string;
};
export type RemoveGranularAclsResponse = string;
export type SetCaptureConfigData = {
    /**
     * capture config
     */
    requestBody: {
        trigger_kind: CaptureTriggerKind;
        path: string;
        is_flow: boolean;
        trigger_config?: {
            [key: string]: unknown;
        };
    };
    workspace: string;
};
export type SetCaptureConfigResponse = {
    [key: string]: unknown;
};
export type PingCaptureConfigData = {
    path: string;
    runnableKind: 'script' | 'flow';
    triggerKind: CaptureTriggerKind;
    workspace: string;
};
export type PingCaptureConfigResponse = unknown;
export type GetCaptureConfigsData = {
    path: string;
    runnableKind: 'script' | 'flow';
    workspace: string;
};
export type GetCaptureConfigsResponse = Array<CaptureConfig>;
export type ListCapturesData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    path: string;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    runnableKind: 'script' | 'flow';
    triggerKind?: CaptureTriggerKind;
    workspace: string;
};
export type ListCapturesResponse = Array<Capture>;
export type MoveCapturesAndConfigsData = {
    path: string;
    /**
     * move captures and configs to a new path
     */
    requestBody: {
        new_path?: string;
    };
    runnableKind: 'script' | 'flow';
    workspace: string;
};
export type MoveCapturesAndConfigsResponse = string;
export type GetCaptureData = {
    id: number;
    workspace: string;
};
export type GetCaptureResponse = Capture;
export type DeleteCaptureData = {
    id: number;
    workspace: string;
};
export type DeleteCaptureResponse = unknown;
export type StarData = {
    requestBody?: {
        path?: string;
        favorite_kind?: 'flow' | 'app' | 'script' | 'raw_app' | 'asset' | 'bpmn_flow';
    };
    workspace: string;
};
export type StarResponse = unknown;
export type UnstarData = {
    requestBody?: {
        path?: string;
        favorite_kind?: 'flow' | 'app' | 'script' | 'raw_app' | 'asset' | 'bpmn_flow';
    };
    workspace: string;
};
export type UnstarResponse = unknown;
export type GetInputHistoryData = {
    /**
     * filter on jobs containing those args as a json subset (@> in postgres)
     */
    args?: string;
    includePreview?: boolean;
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    runnableId?: string;
    runnableType?: RunnableType;
    workspace: string;
};
export type GetInputHistoryResponse = Array<Input>;
export type GetArgsFromHistoryOrSavedInputData = {
    allowLarge?: boolean;
    input?: boolean;
    jobOrInputId: string;
    workspace: string;
};
export type GetArgsFromHistoryOrSavedInputResponse = unknown;
export type ListInputsData = {
    /**
     * which page to return (start at 1, default 1)
     */
    page?: number;
    /**
     * number of items to return for a given page (default 30, max 100)
     */
    perPage?: number;
    runnableId?: string;
    runnableType?: RunnableType;
    workspace: string;
};
export type ListInputsResponse = Array<Input>;
export type CreateInputData = {
    /**
     * Input
     */
    requestBody: CreateInput;
    runnableId?: string;
    runnableType?: RunnableType;
    workspace: string;
};
export type CreateInputResponse = string;
export type UpdateInputData = {
    /**
     * UpdateInput
     */
    requestBody: UpdateInput;
    workspace: string;
};
export type UpdateInputResponse = string;
export type DeleteInputData = {
    input: string;
    workspace: string;
};
export type DeleteInputResponse = string;
export type DuckdbConnectionSettingsData = {
    /**
     * S3 resource to connect to
     */
    requestBody: {
        s3_resource?: S3Resource;
    };
    workspace: string;
};
export type DuckdbConnectionSettingsResponse = {
    connection_settings_str?: string;
};
export type DuckdbConnectionSettingsV2Data = {
    /**
     * S3 resource path to use to generate the connection settings. If empty, the S3 resource defined in the workspace settings will be used
     */
    requestBody: {
        s3_resource_path?: string;
    };
    workspace: string;
};
export type DuckdbConnectionSettingsV2Response = {
    connection_settings_str: string;
    azure_container_path?: string;
};
export type PolarsConnectionSettingsData = {
    /**
     * S3 resource to connect to
     */
    requestBody: {
        s3_resource?: S3Resource;
    };
    workspace: string;
};
export type PolarsConnectionSettingsResponse = {
    endpoint_url: string;
    key?: string;
    secret?: string;
    use_ssl: boolean;
    cache_regions: boolean;
    client_kwargs: PolarsClientKwargs;
};
export type PolarsConnectionSettingsV2Data = {
    /**
     * S3 resource path to use to generate the connection settings. If empty, the S3 resource defined in the workspace settings will be used
     */
    requestBody: {
        s3_resource_path?: string;
    };
    workspace: string;
};
export type PolarsConnectionSettingsV2Response = {
    s3fs_args: {
        endpoint_url: string;
        key?: string;
        secret?: string;
        use_ssl: boolean;
        cache_regions: boolean;
        client_kwargs: PolarsClientKwargs;
    };
    storage_options: {
        aws_endpoint_url: string;
        aws_access_key_id?: string;
        aws_secret_access_key?: string;
        aws_region: string;
        aws_allow_http: string;
    };
};
export type S3ResourceInfoData = {
    /**
     * S3 resource path to use. If empty, the S3 resource defined in the workspace settings will be used
     */
    requestBody: {
        s3_resource_path?: string;
    };
    workspace: string;
};
export type S3ResourceInfoResponse = S3Resource;
export type DatasetStorageTestConnectionData = {
    storage?: string;
    workspace: string;
};
export type DatasetStorageTestConnectionResponse = unknown;
export type ListStoredFilesData = {
    marker?: string;
    maxKeys: number;
    prefix?: string;
    storage?: string;
    workspace: string;
};
export type ListStoredFilesResponse = {
    next_marker?: string;
    orvanta_large_files: Array<OrvantaLargeFile>;
    restricted_access?: boolean;
};
export type LoadFileMetadataData = {
    fileKey: string;
    storage?: string;
    workspace: string;
};
export type LoadFileMetadataResponse = OrvantaFileMetadata;
export type LoadFilePreviewData = {
    csvHasHeader?: boolean;
    csvSeparator?: string;
    fileKey: string;
    fileMimeType?: string;
    fileSizeInBytes?: number;
    readBytesFrom?: number;
    readBytesLength?: number;
    storage?: string;
    workspace: string;
};
export type LoadFilePreviewResponse = OrvantaFilePreview;
export type ListGitRepoFilesData = {
    marker?: string;
    maxKeys: number;
    prefix?: string;
    storage?: string;
    workspace: string;
};
export type ListGitRepoFilesResponse = {
    next_marker?: string;
    orvanta_large_files: Array<OrvantaLargeFile>;
    restricted_access?: boolean;
};
export type LoadGitRepoFilePreviewData = {
    csvHasHeader?: boolean;
    csvSeparator?: string;
    fileKey: string;
    fileMimeType?: string;
    fileSizeInBytes?: number;
    readBytesFrom?: number;
    readBytesLength?: number;
    storage?: string;
    workspace: string;
};
export type LoadGitRepoFilePreviewResponse = OrvantaFilePreview;
export type LoadGitRepoFileMetadataData = {
    fileKey: string;
    storage?: string;
    workspace: string;
};
export type LoadGitRepoFileMetadataResponse = OrvantaFileMetadata;
export type CheckS3FolderExistsData = {
    /**
     * S3 file key to check (e.g., gitrepos/{workspace_id}/u/user/resource/{commit_hash})
     */
    fileKey: string;
    /**
     * If provided, the folder is only considered to exist when this exact
     * sentinel file is present under file_key. Lets callers distinguish a
     * fully populated folder from a partial upload.
     *
     */
    markerFile?: string;
    workspace: string;
};
export type CheckS3FolderExistsResponse = {
    /**
     * Whether the path exists
     */
    exists: boolean;
    /**
     * Whether the path is a folder (true) or file (false)
     */
    is_folder: boolean;
};
export type LoadParquetPreviewData = {
    limit?: number;
    offset?: number;
    path: string;
    searchCol?: string;
    searchTerm?: string;
    sortCol?: string;
    sortDesc?: boolean;
    storage?: string;
    workspace: string;
};
export type LoadParquetPreviewResponse = unknown;
export type LoadTableRowCountData = {
    path: string;
    searchCol?: string;
    searchTerm?: string;
    storage?: string;
    workspace: string;
};
export type LoadTableRowCountResponse = {
    count?: number;
};
export type LoadCsvPreviewData = {
    csvSeparator?: string;
    limit?: number;
    offset?: number;
    path: string;
    searchCol?: string;
    searchTerm?: string;
    sortCol?: string;
    sortDesc?: boolean;
    storage?: string;
    workspace: string;
};
export type LoadCsvPreviewResponse = unknown;
export type DeleteS3FileData = {
    fileKey: string;
    storage?: string;
    workspace: string;
};
export type DeleteS3FileResponse = unknown;
export type MoveS3FileData = {
    destFileKey: string;
    srcFileKey: string;
    storage?: string;
    workspace: string;
};
export type MoveS3FileResponse = unknown;
export type FileUploadData = {
    contentDisposition?: string;
    contentType?: string;
    fileExtension?: string;
    fileKey?: string;
    /**
     * File content
     */
    requestBody: (Blob | File);
    resourceType?: string;
    s3ResourcePath?: string;
    storage?: string;
    workspace: string;
};
export type FileUploadResponse = {
    file_key: string;
};
export type GitRepoViewerFileUploadData = {
    contentDisposition?: string;
    contentType?: string;
    fileExtension?: string;
    fileKey?: string;
    /**
     * File content
     */
    requestBody: (Blob | File);
    resourceType?: string;
    s3ResourcePath?: string;
    storage?: string;
    workspace: string;
};
export type GitRepoViewerFileUploadResponse = {
    file_key: string;
};
export type FileDownloadData = {
    fileKey: string;
    resourceType?: string;
    s3ResourcePath?: string;
    storage?: string;
    workspace: string;
};
export type FileDownloadResponse = (Blob | File);
export type FileDownloadParquetAsCsvData = {
    fileKey: string;
    resourceType?: string;
    s3ResourcePath?: string;
    workspace: string;
};
export type FileDownloadParquetAsCsvResponse = string;
export type GetJobMetricsData = {
    id: string;
    /**
     * parameters for statistics retrieval
     */
    requestBody: {
        timeseries_max_datapoints?: number;
        from_timestamp?: string;
        to_timestamp?: string;
    };
    workspace: string;
};
export type GetJobMetricsResponse = {
    metrics_metadata?: Array<MetricMetadata>;
    scalar_metrics?: Array<ScalarMetric>;
    timeseries_metrics?: Array<TimeseriesMetric>;
};
export type SetJobProgressData = {
    id: string;
    /**
     * parameters for statistics retrieval
     */
    requestBody: {
        percent?: number;
        flow_job_id?: string;
    };
    workspace: string;
};
export type SetJobProgressResponse = unknown;
export type GetJobProgressData = {
    id: string;
    workspace: string;
};
export type GetJobProgressResponse = number;
export type ListLogFilesData = {
    /**
     * filter on created after (exclusive) timestamp
     */
    after?: string;
    /**
     * filter on started before (inclusive) timestamp
     */
    before?: string;
    withError?: boolean;
};
export type ListLogFilesResponse = Array<{
    hostname: string;
    mode: string;
    worker_group?: string;
    log_ts: string;
    file_path: string;
    ok_lines?: number;
    err_lines?: number;
    json_fmt: boolean;
}>;
export type GetLogFileData = {
    path: string;
};
export type GetLogFileResponse = string;
export type ListConcurrencyGroupsResponse = Array<ConcurrencyGroup>;
export type DeleteConcurrencyGroupData = {
    concurrencyId: string;
};
export type DeleteConcurrencyGroupResponse = unknown;
export type GetConcurrencyKeyData = {
    id: string;
};
export type GetConcurrencyKeyResponse = string;
export type SearchJobsIndexData = {
    paginationOffset?: number;
    searchQuery: string;
    workspace: string;
};
export type SearchJobsIndexResponse = {
    /**
     * a list of the terms that couldn't be parsed (and thus ignored)
     */
    query_parse_errors?: Array<(string)>;
    /**
     * the jobs that matched the query
     */
    hits?: Array<JobSearchHit>;
    /**
     * how many jobs matched in total
     */
    hit_count?: number;
    /**
     * Metadata about the index current state
     */
    index_metadata?: {
        /**
         * Datetime of the most recently indexed job
         */
        indexed_until?: string;
        /**
         * Is the current indexer service being replaced
         */
        lost_lock_ownership?: boolean;
        /**
         * Maximum time window in seconds for indexing
         */
        max_index_time_window_secs?: number;
    };
};
export type SearchLogsIndexData = {
    hostname: string;
    maxTs?: string;
    minTs?: string;
    mode: string;
    searchQuery: string;
    workerGroup?: string;
};
export type SearchLogsIndexResponse = {
    /**
     * a list of the terms that couldn't be parsed (and thus ignored)
     */
    query_parse_errors?: Array<(string)>;
    /**
     * log files that matched the query
     */
    hits?: Array<LogSearchHit>;
};
export type CountSearchLogsIndexData = {
    maxTs?: string;
    minTs?: string;
    searchQuery: string;
};
export type CountSearchLogsIndexResponse = {
    /**
     * a list of the terms that couldn't be parsed (and thus ignored)
     */
    query_parse_errors?: Array<(string)>;
    /**
     * count of log lines that matched the query per hostname
     */
    count_per_host?: {
        [key: string]: unknown;
    };
};
export type GetIndexDiskStorageSizesResponse = {
    job_index_disk_size_bytes?: number | null;
    log_index_disk_size_bytes?: number | null;
};
export type ClearIndexData = {
    idxName: 'JobIndex' | 'ServiceLogIndex';
};
export type ClearIndexResponse = string;
export type GetIndexStorageSizesResponse = {
    job_index?: {
        disk_size_bytes?: number | null;
        s3_size_bytes?: number | null;
    };
    service_log_index?: {
        disk_size_bytes?: number | null;
        s3_size_bytes?: number | null;
    };
};
export type GetIndexerStatusResponse = {
    job_indexer?: {
        is_alive?: boolean;
        last_locked_at?: string | null;
        owner?: string | null;
        storage?: {
            disk_size_bytes?: number | null;
            s3_size_bytes?: number | null;
        };
    };
    log_indexer?: {
        is_alive?: boolean;
        last_locked_at?: string | null;
        owner?: string | null;
        storage?: {
            disk_size_bytes?: number | null;
            s3_size_bytes?: number | null;
        };
    };
};
export type ListAssetsData = {
    /**
     * Filter by asset kinds (multiple values allowed)
     */
    assetKinds?: string;
    /**
     * Filter by asset path (case-insensitive partial match)
     */
    assetPath?: string;
    /**
     * broad search across multiple fields (case-insensitive substring match)
     */
    broadFilter?: string;
    /**
     * JSONB subset match filter for columns using base64 encoded JSON
     */
    columns?: string;
    /**
     * Cursor timestamp for pagination (created_at of last item from previous page)
     */
    cursorCreatedAt?: string;
    /**
     * Cursor ID for pagination (id of last item from previous page)
     */
    cursorId?: number;
    /**
     * exact path match filter
     */
    path?: string;
    /**
     * Number of items per page (max 1000, default 50)
     */
    perPage?: number;
    /**
     * Filter by usage path (case-insensitive partial match)
     */
    usagePath?: string;
    workspace: string;
};
export type ListAssetsResponse = {
    assets: Array<{
        path: string;
        kind: AssetKind;
        usages: Array<{
            path: string;
            kind: AssetUsageKind;
            access_type?: AssetUsageAccessType;
            /**
             * The columns used (for tables)
             */
            columns?: {
                [key: string]: AssetUsageAccessType;
            };
            /**
             * When the asset was detected
             */
            created_at?: string;
            metadata?: {
                /**
                 * The path of the script/flow that was run (only present when kind is 'job')
                 */
                runnable_path?: string;
                /**
                 * The kind of job (script, flow, preview, etc.) (only present when kind is 'job')
                 */
                job_kind?: string;
            };
        }>;
        metadata?: {
            /**
             * The type of the resource (only present when kind is 'resource')
             */
            resource_type?: string;
        };
    }>;
    /**
     * Cursor for the next page (null if no more pages)
     */
    next_cursor?: {
        /**
         * Timestamp to use for next page
         */
        created_at?: string;
        /**
         * ID to use for next page
         */
        id?: number;
    } | null;
};
export type ListAssetsByUsageData = {
    /**
     * list assets by usages
     */
    requestBody: {
        usages: Array<{
            path: string;
            kind: AssetUsageKind;
        }>;
    };
    workspace: string;
};
export type ListAssetsByUsageResponse = Array<Array<{
    path: string;
    kind: AssetKind;
    access_type?: AssetUsageAccessType;
}>>;
export type ListFavoriteAssetsData = {
    workspace: string;
};
export type ListFavoriteAssetsResponse = Array<{
    /**
     * The asset path
     */
    path: string;
}>;
export type ListVolumesData = {
    workspace: string;
};
export type ListVolumesResponse = Array<Volume>;
export type GetVolumeStorageData = {
    workspace: string;
};
export type GetVolumeStorageResponse = string | null;
export type CreateVolumeData = {
    requestBody: {
        name: string;
    };
    workspace: string;
};
export type CreateVolumeResponse = string;
export type DeleteVolumeData = {
    name: string;
    workspace: string;
};
export type DeleteVolumeResponse = string;
export type ListMcpToolsData = {
    workspace: string;
};
export type ListMcpToolsResponse = Array<EndpointTool>;
export type DiscoverMcpOauthData = {
    requestBody: {
        /**
         * URL of the MCP server to discover OAuth metadata from
         */
        mcp_server_url: string;
    };
};
export type DiscoverMcpOauthResponse = {
    scopes_supported?: Array<(string)>;
    authorization_endpoint?: string;
    token_endpoint?: string;
    registration_endpoint?: string;
    supports_dynamic_registration?: boolean;
};
export type StartMcpOauthPopupData = {
    /**
     * URL of the MCP server to connect to
     */
    mcpServerUrl: string;
    /**
     * Comma/whitespace-separated list of OAuth scopes to request
     */
    scopes?: string;
    /**
     * Workspace the resulting connection will belong to
     */
    workspaceId: string;
};
export type McpOauthCallbackData = {
    /**
     * OAuth authorization code (absent when the authorization server reports an error instead)
     */
    code?: string;
    /**
     * Error code from the authorization server, if the user denied access or the request failed
     */
    error?: string;
    errorDescription?: string;
    /**
     * CSRF state token, single-use, matched against the row created by /mcp/oauth/start
     */
    state: string;
};
export type McpOauthCallbackResponse = string;
export type RefreshMcpOauthData = {
    requestBody: {
        workspace_id: string;
        mcp_server_url: string;
    };
};
export type RefreshMcpOauthResponse = {
    expires_in?: number | null;
};
export type GetMcpOauthClientMetadataResponse = {
    client_name?: string;
    redirect_uris?: Array<(string)>;
    grant_types?: Array<(string)>;
    response_types?: Array<(string)>;
    token_endpoint_auth_method?: string;
};
export type $OpenApiTs = {
    '/version': {
        get: {
            res: {
                /**
                 * git version of backend
                 */
                200: string;
            };
        };
    };
    '/features': {
        get: {
            res: {
                /**
                 * enabled feature keys (now includes shipped `built: true` features, not beta-build-only), whether the ORVANTA_BETA env toggle is on for this process, and the capability catalog. `keys` is exactly `features` filtered on `available`; `features` additionally exposes capabilities that are present in the binary but below the licence tier, which the frontend renders as a locked upgrade prompt rather than hiding. Unauthenticated, so it carries per-entry `min_tier` but never the caller's own tier -- that comes from `/entitlements`.
                 */
                200: {
                    keys: Array<(string)>;
                    beta: boolean;
                    /**
                     * one entry per capability this build actually carries (present in the binary and enabled for this deployment's flavour). Capabilities the binary does not implement are omitted entirely. Additive and deliberately NOT in `required` (#729): during a rolling upgrade an old backend predating this field won't send it, and a generated client that required it would mis-type a valid response as invalid.
                     */
                    features?: Array<{
                        key: string;
                        label: string;
                        group: string;
                        /**
                         * the raw catalog flag. `false` here means the entry is only visible because ORVANTA_BETA is on.
                         */
                        built: boolean;
                        min_tier: 'trial' | 'teams' | 'enterprise';
                        /**
                         * whether the live licence clears `min_tier`
                         */
                        entitled: boolean;
                        /**
                         * fully usable; the filter that reproduces `keys`
                         */
                        available: boolean;
                    }>;
                };
            };
        };
    };
    '/ee_license': {
        get: {
            res: {
                /**
                 * get license id (empty if not ee)
                 */
                200: string;
            };
        };
    };
    '/entitlements': {
        get: {
            res: {
                /**
                 * current tier, edition and limits
                 */
                200: {
                    tier: 'trial' | 'teams' | 'enterprise';
                    edition: 'ote' | 'oee';
                    expires_at?: string | null;
                    limits?: {
                        [key: string]: unknown;
                    };
                };
            };
        };
    };
    '/openapi.yaml': {
        get: {
            res: {
                /**
                 * openapi yaml file content
                 */
                200: string;
            };
        };
    };
    '/health/status': {
        get: {
            req: {
                /**
                 * Force a fresh check, bypassing the cache
                 */
                force?: boolean;
            };
            res: {
                /**
                 * server is healthy or degraded
                 */
                200: HealthStatusResponse;
                /**
                 * server is unhealthy (database unreachable)
                 */
                503: HealthStatusResponse;
            };
        };
    };
    '/health/detailed': {
        get: {
            res: {
                /**
                 * server is healthy or degraded
                 */
                200: DetailedHealthResponse;
                /**
                 * server is unhealthy (database unreachable)
                 */
                503: DetailedHealthResponse;
            };
        };
    };
    '/inkeep': {
        post: {
            req: {
                /**
                 * query to send to the AI documentation assistant
                 */
                requestBody: {
                    /**
                     * The documentation query to send to the AI assistant
                     */
                    query: string;
                };
            };
            res: {
                /**
                 * AI documentation assistant response
                 */
                200: {
                    [key: string]: unknown;
                };
                /**
                 * Enterprise Edition required
                 */
                403: string;
            };
        };
    };
    '/w/{workspace}/audit/get/{id}': {
        get: {
            req: {
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * an audit log
                 */
                200: AuditLog;
            };
        };
    };
    '/w/{workspace}/audit/list': {
        get: {
            req: {
                /**
                 * filter on type of operation
                 */
                actionKind?: 'Create' | 'Update' | 'Delete' | 'Execute';
                /**
                 * filter on created after (exclusive) timestamp
                 */
                after?: string;
                /**
                 * get audit logs for all workspaces
                 */
                allWorkspaces?: boolean;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                before?: string;
                /**
                 * comma separated list of operations to exclude
                 */
                excludeOperations?: string;
                /**
                 * filter on exact or prefix name of operation
                 */
                operation?: string;
                /**
                 * comma separated list of exact operations to include
                 */
                operations?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * filter on exact or prefix name of resource
                 */
                resource?: string;
                /**
                 * filter on exact username of user
                 */
                username?: string;
                workspace: string;
            };
            res: {
                /**
                 * a list of audit logs
                 */
                200: Array<AuditLog>;
            };
        };
    };
    '/auth/login': {
        post: {
            req: {
                /**
                 * credentials
                 */
                requestBody: Login;
            };
            res: {
                /**
                 * Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
                 *
                 */
                200: string;
            };
        };
    };
    '/auth/logout': {
        post: {
            res: {
                /**
                 * clear cookies and clear token (if applicable)
                 */
                200: string;
            };
        };
    };
    '/auth/is_smtp_configured': {
        get: {
            res: {
                /**
                 * returns true if SMTP is configured
                 */
                200: boolean;
            };
        };
    };
    '/auth/is_password_login_disabled': {
        get: {
            res: {
                /**
                 * returns true if password login is disabled
                 */
                200: boolean;
            };
        };
    };
    '/auth/request_password_reset': {
        post: {
            req: {
                /**
                 * email to send password reset link to
                 */
                requestBody: {
                    email: string;
                };
            };
            res: {
                /**
                 * password reset email sent (if user exists)
                 */
                200: PasswordResetResponse;
                /**
                 * SMTP not configured
                 */
                400: unknown;
            };
        };
    };
    '/auth/reset_password': {
        post: {
            req: {
                /**
                 * token and new password
                 */
                requestBody: {
                    token: string;
                    new_password: string;
                };
            };
            res: {
                /**
                 * password reset successfully
                 */
                200: PasswordResetResponse;
                /**
                 * invalid or expired token
                 */
                400: unknown;
            };
        };
    };
    '/w/{workspace}/users/get/{username}': {
        get: {
            req: {
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * user created
                 */
                200: User;
            };
        };
    };
    '/w/{workspace}/users/update/{username}': {
        post: {
            req: {
                /**
                 * new user
                 */
                requestBody: EditWorkspaceUser;
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * edited user
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/users/is_owner/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * is owner
                 */
                200: boolean;
            };
        };
    };
    '/users/setpassword': {
        post: {
            req: {
                /**
                 * set password
                 */
                requestBody: {
                    password: string;
                    /**
                     * Optional. When provided, verified against the caller's current password before the rotation is applied.
                     */
                    current_password?: string;
                };
            };
            res: {
                /**
                 * password set
                 */
                200: string;
            };
        };
    };
    '/users/set_password_of/{user}': {
        post: {
            req: {
                /**
                 * set password
                 */
                requestBody: {
                    password: string;
                };
                user: string;
            };
            res: {
                /**
                 * password set
                 */
                200: string;
            };
        };
    };
    '/users/set_login_type/{user}': {
        post: {
            req: {
                /**
                 * set login type
                 */
                requestBody: {
                    login_type: string;
                };
                user: string;
            };
            res: {
                /**
                 * login type set
                 */
                200: string;
            };
        };
    };
    '/users/create': {
        post: {
            req: {
                /**
                 * user info
                 */
                requestBody: {
                    email: string;
                    password: string;
                    super_admin: boolean;
                    name?: string;
                    company?: string;
                    /**
                     * Skip sending email notifications to the user
                     */
                    skip_email?: boolean;
                };
            };
            res: {
                /**
                 * user created
                 */
                201: string;
            };
        };
    };
    '/users/update/{email}': {
        post: {
            req: {
                email: string;
                /**
                 * new user info
                 */
                requestBody: {
                    is_super_admin?: boolean;
                    is_devops?: boolean;
                    name?: string;
                    disabled?: boolean;
                };
            };
            res: {
                /**
                 * user updated
                 */
                200: string;
            };
        };
    };
    '/users/username_info/{email}': {
        get: {
            req: {
                email: string;
            };
            res: {
                /**
                 * user renamed
                 */
                200: {
                    username: string;
                    workspace_usernames: Array<{
                        workspace_id: string;
                        username: string;
                    }>;
                };
            };
        };
    };
    '/users/rename/{email}': {
        post: {
            req: {
                email: string;
                /**
                 * new username
                 */
                requestBody: {
                    new_username: string;
                };
            };
            res: {
                /**
                 * user renamed
                 */
                200: string;
            };
        };
    };
    '/users/delete/{email}': {
        delete: {
            req: {
                email: string;
            };
            res: {
                /**
                 * user deleted
                 */
                200: string;
            };
        };
    };
    '/users/overwrite': {
        post: {
            req: {
                /**
                 * List of users
                 */
                requestBody: Array<ExportedUser>;
            };
            res: {
                /**
                 * Success message
                 */
                200: string;
            };
        };
    };
    '/users/export': {
        get: {
            res: {
                /**
                 * exported users
                 */
                200: Array<ExportedUser>;
            };
        };
    };
    '/users/ext_jwt_tokens': {
        get: {
            req: {
                /**
                 * only tokens used in the last 30 days
                 */
                activeOnly?: boolean;
                page?: number;
                perPage?: number;
            };
            res: {
                /**
                 * list of external JWT tokens
                 */
                200: Array<ExternalJwtToken>;
            };
        };
    };
    '/users/onboarding': {
        post: {
            req: {
                requestBody: {
                    touch_point?: string;
                    use_case?: string;
                };
            };
            res: {
                /**
                 * Onboarding data submitted successfully
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/users/delete/{username}': {
        delete: {
            req: {
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * delete user
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/users/offboard_preview/{username}': {
        get: {
            req: {
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * offboard preview with object counts
                 */
                200: OffboardPreview;
            };
        };
    };
    '/w/{workspace}/users/offboard/{username}': {
        post: {
            req: {
                requestBody: OffboardRequest;
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * offboard response with conflicts or summary
                 */
                200: OffboardResponse;
            };
        };
    };
    '/users/offboard_preview/{email}': {
        get: {
            req: {
                email: string;
            };
            res: {
                /**
                 * per-workspace offboard previews
                 */
                200: GlobalOffboardPreview;
            };
        };
    };
    '/users/offboard/{email}': {
        post: {
            req: {
                email: string;
                requestBody: GlobalOffboardRequest;
            };
            res: {
                /**
                 * offboard result
                 */
                200: OffboardResponse;
            };
        };
    };
    '/w/{workspace}/users/convert_to_group/{username}': {
        post: {
            req: {
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * convert user to group user
                 */
                200: string;
            };
        };
    };
    '/users/email': {
        get: {
            res: {
                /**
                 * user email
                 */
                200: string;
            };
        };
    };
    '/users/refresh_token': {
        get: {
            req: {
                ifExpiringInLessThanS?: number;
            };
            res: {
                /**
                 * new token
                 */
                200: string;
            };
        };
    };
    '/users/tutorial_progress': {
        get: {
            res: {
                /**
                 * tutorial progress
                 */
                200: {
                    progress?: number;
                    skipped_all?: boolean;
                };
            };
        };
        post: {
            req: {
                /**
                 * progress update
                 */
                requestBody: {
                    progress?: number;
                    skipped_all?: boolean;
                };
            };
            res: {
                /**
                 * tutorial progress
                 */
                200: string;
            };
        };
    };
    '/users/leave_instance': {
        post: {
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/users/usage': {
        get: {
            res: {
                /**
                 * free usage
                 */
                200: number;
            };
        };
    };
    '/users/seats': {
        get: {
            res: {
                /**
                 * user seat usage and caps (cap 0 = unlimited)
                 */
                200: {
                    developers: number;
                    operators: number;
                    developer_seats: number;
                    operator_seats: number;
                    total_users: number;
                    users_limit: number;
                };
            };
        };
    };
    '/users/all_runnables': {
        get: {
            res: {
                /**
                 * free all runnables
                 */
                200: {
                    workspace: string;
                    endpoint_async: string;
                    endpoint_sync: string;
                    summary: string;
                    description?: string;
                    kind: string;
                };
            };
        };
    };
    '/users/whoami': {
        get: {
            res: {
                /**
                 * user email
                 */
                200: GlobalUserInfo;
            };
        };
    };
    '/users/list_invites': {
        get: {
            res: {
                /**
                 * list all workspace invites
                 */
                200: Array<WorkspaceInvite>;
            };
        };
    };
    '/w/{workspace}/users/whoami': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * user
                 */
                200: User;
            };
        };
    };
    '/users/accept_invite': {
        post: {
            req: {
                /**
                 * accept invite
                 */
                requestBody: {
                    workspace_id: string;
                    username?: string;
                };
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/users/decline_invite': {
        post: {
            req: {
                /**
                 * decline invite
                 */
                requestBody: {
                    workspace_id: string;
                };
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/users/impersonate_service_account': {
        post: {
            req: {
                requestBody: {
                    username: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * impersonation token
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/users/exit_impersonation': {
        post: {
            req: {
                requestBody: {
                    token: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * exited impersonation
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/users/whois/{username}': {
        get: {
            req: {
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * user
                 */
                200: User;
            };
        };
    };
    '/users/exists/{email}': {
        get: {
            req: {
                email: string;
            };
            res: {
                /**
                 * user
                 */
                200: boolean;
            };
        };
    };
    '/users/list_as_super_admin': {
        get: {
            req: {
                /**
                 * filter only active users
                 */
                activeOnly?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
            };
            res: {
                /**
                 * user
                 */
                200: Array<GlobalUserInfo>;
            };
        };
    };
    '/w/{workspace}/users/list': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * user
                 */
                200: Array<User>;
            };
        };
    };
    '/w/{workspace}/users/list_usage': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * user
                 */
                200: Array<UserUsage>;
            };
        };
    };
    '/w/{workspace}/users/list_usernames': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * user
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/users/username_to_email/{username}': {
        get: {
            req: {
                username: string;
                workspace: string;
            };
            res: {
                /**
                 * email
                 */
                200: string;
            };
        };
    };
    '/users/tokens/create': {
        post: {
            req: {
                /**
                 * new token
                 */
                requestBody: NewToken;
            };
            res: {
                /**
                 * token created
                 */
                201: string;
            };
        };
    };
    '/users/tokens/impersonate': {
        post: {
            req: {
                /**
                 * new token
                 */
                requestBody: NewTokenImpersonate;
            };
            res: {
                /**
                 * token created
                 */
                201: string;
            };
        };
    };
    '/users/tokens/delete/{token_prefix}': {
        delete: {
            req: {
                tokenPrefix: string;
            };
            res: {
                /**
                 * delete token
                 */
                200: string;
            };
        };
    };
    '/users/tokens/update_scopes/{token_prefix}': {
        post: {
            req: {
                /**
                 * new scopes (null or omitted = full access)
                 */
                requestBody: {
                    scopes?: Array<(string)> | null;
                };
                tokenPrefix: string;
            };
            res: {
                /**
                 * scopes updated
                 */
                200: string;
            };
        };
    };
    '/users/tokens/list': {
        get: {
            req: {
                excludeEphemeral?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
            };
            res: {
                /**
                 * truncated token
                 */
                200: Array<TruncatedToken>;
            };
        };
    };
    '/oauth/login_callback/{client_name}': {
        post: {
            req: {
                clientName: string;
                /**
                 * Partially filled script
                 */
                requestBody: {
                    code?: string;
                    state?: string;
                };
            };
            res: {
                /**
                 * Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
                 *
                 */
                200: string;
            };
        };
    };
    '/github_app/connected_repositories': {
        get: {
            req: {
                /**
                 * Page number for pagination (default 1)
                 */
                page?: number;
            };
            res: {
                /**
                 * connected repositories
                 */
                200: GithubInstallations;
            };
        };
    };
    '/w/{workspace}/github_app/install_from_workspace': {
        post: {
            req: {
                requestBody: {
                    /**
                     * The ID of the workspace containing the installation to copy
                     */
                    source_workspace_id: string;
                    /**
                     * The ID of the GitHub installation to copy
                     */
                    installation_id: number;
                };
                workspace: string;
            };
            res: {
                /**
                 * Installation successfully copied
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/github_app/installation/{installation_id}': {
        delete: {
            req: {
                /**
                 * The ID of the GitHub installation to delete
                 */
                installationId: number;
                workspace: string;
            };
            res: {
                /**
                 * Installation successfully deleted
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/github_app/export/{installationId}': {
        get: {
            req: {
                installationId: number;
                workspace: string;
            };
            res: {
                /**
                 * Successfully exported the JWT token
                 */
                200: {
                    jwt_token?: string;
                };
            };
        };
    };
    '/w/{workspace}/github_app/import': {
        post: {
            req: {
                requestBody: {
                    jwt_token: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * Successfully imported the installation
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/github_app/ghes_installation_callback': {
        post: {
            req: {
                requestBody: {
                    /**
                     * The GitHub App installation ID from GHES
                     */
                    installation_id: number;
                };
                workspace: string;
            };
            res: {
                /**
                 * GHES installation registered successfully
                 */
                200: unknown;
            };
        };
    };
    '/github_app/ghes_config': {
        get: {
            res: {
                /**
                 * GHES app configuration
                 */
                200: {
                    base_url: string;
                    app_slug: string;
                    client_id: string;
                    app_owner?: string | null;
                };
            };
        };
    };
    '/workspaces/list': {
        get: {
            res: {
                /**
                 * all workspaces
                 */
                200: Array<Workspace>;
            };
        };
    };
    '/workspaces/allowed_domain_auto_invite': {
        get: {
            res: {
                /**
                 * domain allowed or not
                 */
                200: boolean;
            };
        };
    };
    '/workspaces/users': {
        get: {
            res: {
                /**
                 * workspace with associated username
                 */
                200: UserWorkspaceList;
            };
        };
    };
    '/w/{workspace}/workspaces/get_as_superadmin': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * workspace
                 */
                200: Workspace;
            };
        };
    };
    '/workspaces/list_as_superadmin': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
            };
            res: {
                /**
                 * workspaces
                 */
                200: Array<Workspace>;
            };
        };
    };
    '/workspaces/create': {
        post: {
            req: {
                /**
                 * new token
                 */
                requestBody: CreateWorkspace;
            };
            res: {
                /**
                 * token created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/workspaces/create_workspace_fork_branch': {
        post: {
            req: {
                /**
                 * new forked workspace
                 */
                requestBody: CreateWorkspaceFork;
                workspace: string;
            };
            res: {
                /**
                 * forked workspace branch created
                 */
                201: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/workspaces/create_fork': {
        post: {
            req: {
                /**
                 * new forked workspace
                 */
                requestBody: CreateWorkspaceFork;
                workspace: string;
            };
            res: {
                /**
                 * forked workspace created
                 */
                201: string;
            };
        };
    };
    '/workspaces/exists': {
        post: {
            req: {
                /**
                 * id of workspace
                 */
                requestBody: {
                    id: string;
                };
            };
            res: {
                /**
                 * status
                 */
                200: boolean;
            };
        };
    };
    '/workspaces/exists_username': {
        post: {
            req: {
                requestBody: {
                    id: string;
                    username: string;
                };
            };
            res: {
                /**
                 * status
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/github_app/token': {
        post: {
            req: {
                /**
                 * jwt job token
                 */
                requestBody: {
                    job_token: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * github app token
                 */
                200: {
                    token: string;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/invite_user': {
        post: {
            req: {
                /**
                 * WorkspaceInvite
                 */
                requestBody: {
                    email: string;
                    is_admin: boolean;
                    operator: boolean;
                    parent_workspace_id?: string | null;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/add_user': {
        post: {
            req: {
                /**
                 * WorkspaceInvite
                 */
                requestBody: {
                    email: string;
                    is_admin: boolean;
                    username?: string;
                    operator: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/create_service_account': {
        post: {
            req: {
                requestBody: {
                    username: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * service account created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/workspaces/delete_invite': {
        post: {
            req: {
                /**
                 * WorkspaceInvite
                 */
                requestBody: {
                    email: string;
                    is_admin: boolean;
                    operator: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/archive': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/workspaces/unarchive/{workspace}': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/workspaces/delete/{workspace}': {
        delete: {
            req: {
                onlyDeleteForks?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/leave': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/get_workspace_name': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/change_workspace_name': {
        post: {
            req: {
                requestBody?: {
                    new_name?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/change_workspace_id': {
        post: {
            req: {
                requestBody?: {
                    new_id?: string;
                    new_name?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/change_workspace_color': {
        post: {
            req: {
                requestBody?: {
                    color?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/operator_settings': {
        post: {
            req: {
                requestBody: OperatorSettings;
                workspace: string;
            };
            res: {
                /**
                 * Operator settings updated successfully
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/compare/{target_workspace_id}': {
        get: {
            req: {
                /**
                 * The ID of the workspace to compare with
                 */
                targetWorkspaceId: string;
                workspace: string;
            };
            res: {
                /**
                 * Workspace comparison results
                 */
                200: WorkspaceComparison;
            };
        };
    };
    '/w/{workspace}/workspaces/reset_diff_tally/{fork_workspace_id}': {
        post: {
            req: {
                /**
                 * The ID of the workspace to compare with
                 */
                forkWorkspaceId: string;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/list_pending_invites': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * user
                 */
                200: Array<WorkspaceInvite>;
            };
        };
    };
    '/w/{workspace}/workspaces/get_public_settings': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    workspace_id: string;
                    slack_name?: string;
                    slack_team_id?: string;
                    teams_team_id?: string;
                    teams_team_name?: string;
                    teams_team_guid?: string;
                    large_file_storage?: LargeFileStorage;
                    datatable?: DataTableSettings;
                    deploy_ui?: WorkspaceDeployUISettings;
                    mute_critical_alerts?: boolean;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/get_settings': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    workspace_id?: string;
                    slack_name?: string;
                    slack_team_id?: string;
                    slack_command_script?: string;
                    slack_oauth_client_id?: string;
                    slack_oauth_client_secret?: string;
                    teams_team_id?: string;
                    teams_command_script?: string;
                    teams_team_name?: string;
                    teams_team_guid?: string;
                    auto_invite?: AutoInviteConfig;
                    plan?: string;
                    customer_id?: string;
                    webhook?: string;
                    deploy_to?: string;
                    ai_config?: AIConfig;
                    error_handler?: ErrorHandlerConfig;
                    success_handler?: SuccessHandlerConfig;
                    large_file_storage?: LargeFileStorage;
                    ducklake?: DucklakeSettings;
                    datatable?: DataTableSettings;
                    git_sync?: WorkspaceGitSyncSettings;
                    deploy_ui?: WorkspaceDeployUISettings;
                    default_app?: string;
                    default_scripts?: WorkspaceDefaultScripts;
                    mute_critical_alerts?: boolean;
                    color?: string;
                    operator_settings?: OperatorSettings;
                    /**
                     * Rate limit for public app executions per minute per server. NULL or 0 means disabled.
                     */
                    public_app_execution_limit_per_minute?: number;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/get_deploy_to': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    deploy_to?: string;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/is_premium': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/workspaces/tarball': {
        get: {
            req: {
                /**
                 * "zip" or "tar" (default)
                 */
                archiveType?: 'zip' | 'tar';
                /**
                 * "bun" or "deno" -- selects the .ts extension used for Bun-language scripts
                 */
                defaultTs?: 'bun' | 'deno';
                /**
                 * Opt-in, default false, added in #729. `dmn_decision` rows are
                 * workspace source code, same as flows -- but unlike flows this
                 * defaults off, matching `include_schedules`/`include_triggers`:
                 * the CLI (#822) has sent this parameter since before the backend
                 * read it, and independently gates its own local sync file map on
                 * a matching `--include-dmn` flag. Both gates exist because a path
                 * present locally but absent from the tarball is indistinguishable
                 * from "deleted upstream" to `sync pull`, and an opt-out default
                 * would have archived every locally-pushed decision on the first
                 * pull after this endpoint started supporting DMN at all.
                 *
                 */
                includeDmn?: boolean;
                includeGroups?: boolean;
                includeKey?: boolean;
                includeSchedules?: boolean;
                includeSettings?: boolean;
                includeTriggers?: boolean;
                includeUsers?: boolean;
                includeWorkspaceDependencies?: boolean;
                plainSecret?: boolean;
                /**
                 * "v1" (legacy flat format, default) or "v2" (grouped format)
                 */
                settingsVersion?: 'v1' | 'v2';
                skipResources?: boolean;
                skipResourceTypes?: boolean;
                skipSecrets?: boolean;
                skipVariables?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * workspace archive (tar or zip, depending on archive_type)
                 */
                200: (Blob | File);
            };
        };
    };
    '/w/{workspace}/workspaces/threshold_alert': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    threshold_alert_amount?: number;
                    last_alert_sent?: string;
                };
            };
        };
        post: {
            req: {
                /**
                 * threshold alert info
                 */
                requestBody: {
                    threshold_alert_amount?: number;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/rebuild_dependency_map': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/get_dependents/{imported_path}': {
        get: {
            req: {
                /**
                 * The imported path to get dependents for
                 */
                importedPath: string;
                workspace: string;
            };
            res: {
                /**
                 * list of dependents
                 */
                200: Array<DependencyDependent>;
            };
        };
    };
    '/w/{workspace}/workspaces/get_imports/{importer_path}': {
        get: {
            req: {
                /**
                 * The script path to get imports for
                 */
                importerPath: string;
                workspace: string;
            };
            res: {
                /**
                 * list of imported script paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/workspaces/get_dependents_amounts': {
        post: {
            req: {
                /**
                 * List of imported paths to get dependents counts for
                 */
                requestBody: Array<(string)>;
                workspace: string;
            };
            res: {
                /**
                 * list of dependents amounts
                 */
                200: Array<DependentsAmount>;
            };
        };
    };
    '/w/{workspace}/workspaces/get_dependency_map': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * dmap
                 */
                200: Array<DependencyMap>;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_slack_command': {
        post: {
            req: {
                /**
                 * WorkspaceInvite
                 */
                requestBody: {
                    slack_command_script?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/slack_oauth_config': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * slack oauth config
                 */
                200: {
                    slack_oauth_client_id?: string | null;
                    /**
                     * Masked with *** if set
                     */
                    slack_oauth_client_secret?: string | null;
                };
            };
        };
        post: {
            req: {
                /**
                 * Slack OAuth Configuration
                 */
                requestBody: {
                    slack_oauth_client_id: string;
                    slack_oauth_client_secret: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
        delete: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_teams_command': {
        post: {
            req: {
                /**
                 * script/flow to run on the /orvanta Teams command. Omit or null to clear it.
                 */
                requestBody: {
                    teams_command_script?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/available_teams_ids': {
        get: {
            req: {
                /**
                 * Pagination cursor URL from previous response. Pass this to fetch the next page of results.
                 */
                nextLink?: string;
                /**
                 * Search teams by name. If omitted, returns first page of all teams.
                 */
                search?: string;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    teams?: Array<{
                        team_name?: string;
                        team_id?: string;
                    }>;
                    /**
                     * Total number of teams across all pages
                     */
                    total_count?: number;
                    /**
                     * Number of teams per page (configurable via TEAMS_PER_PAGE env var)
                     */
                    per_page?: number;
                    /**
                     * URL to fetch next page of results. Null if no more pages.
                     */
                    next_link?: string | null;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/available_teams_channels': {
        get: {
            req: {
                /**
                 * Microsoft Teams team ID
                 */
                teamId: string;
                workspace: string;
            };
            res: {
                /**
                 * List of channels for the specified team
                 */
                200: {
                    channels?: Array<{
                        channel_name?: string;
                        channel_id?: string;
                    }>;
                    total_count?: number;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/connect_teams': {
        post: {
            req: {
                /**
                 * connect teams
                 */
                requestBody: {
                    team_id?: string;
                    team_name?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/connect_slack': {
        post: {
            req: {
                /**
                 * connect slack with a pre-minted bot token
                 */
                requestBody: {
                    /**
                     * xoxb-... bot token obtained at api.slack.com/apps
                     */
                    bot_token: string;
                    team_id: string;
                    team_name: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/run_slack_message_test_job': {
        post: {
            req: {
                /**
                 * path to hub script to run and its corresponding args
                 */
                requestBody: {
                    hub_script_path?: string;
                    channel?: string;
                    test_msg?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    job_uuid?: string;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/run_teams_message_test_job': {
        post: {
            req: {
                /**
                 * path to hub script to run and its corresponding args
                 */
                requestBody: {
                    hub_script_path?: string;
                    channel?: string;
                    test_msg?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    job_uuid?: string;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/edit_deploy_to': {
        post: {
            req: {
                requestBody: {
                    deploy_to?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_auto_invite': {
        post: {
            req: {
                /**
                 * WorkspaceInvite
                 */
                requestBody: {
                    operator?: boolean;
                    invite_all?: boolean;
                    auto_add?: boolean;
                    /**
                     * Explicit auto-invite domain to use instead of deriving one from the caller's own email. A workspace admin may only set their own domain; setting a different domain requires the caller to be a superadmin. Case-insensitive (stored lowercased); non-ASCII is rejected. Omitting this field leaves the currently stored domain unchanged; sending an explicit empty string resets it to the caller's own domain.
                     *
                     */
                    domain?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_instance_groups': {
        post: {
            req: {
                /**
                 * Instance Groups Configuration
                 */
                requestBody: {
                    groups?: Array<(string)>;
                    roles?: {
                        [key: string]: (string);
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_webhook': {
        post: {
            req: {
                /**
                 * WorkspaceWebhook
                 */
                requestBody: {
                    webhook?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_copilot_config': {
        post: {
            req: {
                /**
                 * WorkspaceCopilotConfig
                 */
                requestBody: AIConfig;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    effective_ai_config: AIConfig;
                    has_instance_ai_config: boolean;
                    uses_instance_ai_config: boolean;
                    instance_ai_summary?: InstanceAISummary;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/get_copilot_settings_state': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    has_instance_ai_config: boolean;
                    uses_instance_ai_config: boolean;
                    instance_ai_summary?: InstanceAISummary;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/get_copilot_info': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: AIConfig;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_error_handler': {
        post: {
            req: {
                /**
                 * WorkspaceErrorHandler
                 */
                requestBody: EditErrorHandler;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_success_handler': {
        post: {
            req: {
                /**
                 * WorkspaceSuccessHandler
                 */
                requestBody: EditSuccessHandler;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_large_file_storage_config': {
        post: {
            req: {
                /**
                 * LargeFileStorage info
                 */
                requestBody: {
                    large_file_storage?: LargeFileStorage;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/list_ducklakes': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/workspaces/list_datatables': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: Array<{
                    name: string;
                    resource_type: 'postgres' | 'instance';
                    resource_path: string;
                }>;
            };
        };
    };
    '/w/{workspace}/workspaces/list_datatable_schemas': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * schemas of all datatables
                 */
                200: Array<DataTableSchema>;
            };
        };
    };
    '/w/{workspace}/workspaces/list_datatable_tables': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * table metadata of all datatables
                 */
                200: Array<DataTableTables>;
            };
        };
    };
    '/w/{workspace}/workspaces/get_datatable_table_schema': {
        get: {
            req: {
                datatableName: string;
                schemaName: string;
                tableName: string;
                workspace: string;
            };
            res: {
                /**
                 * schema of one datatable table
                 */
                200: DataTableTableSchema;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_ducklake_config': {
        post: {
            req: {
                /**
                 * Ducklake settings
                 */
                requestBody: {
                    settings: DucklakeSettings;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_datatable_config': {
        post: {
            req: {
                /**
                 * DataTable settings
                 */
                requestBody: {
                    settings: DataTableSettings;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/create_pg_database': {
        post: {
            req: {
                /**
                 * Create pg database request
                 */
                requestBody: {
                    /**
                     * Datatable source to determine connection info: 'datatable://name' or '$res:path'
                     */
                    source: string;
                    /**
                     * Name for the new database
                     */
                    target_dbname: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/drop_forked_datatable_databases': {
        post: {
            req: {
                requestBody: {
                    datatable_names: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * list of errors (empty if all succeeded)
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/workspaces/import_pg_database': {
        post: {
            req: {
                /**
                 * Import pg database request
                 */
                requestBody: {
                    /**
                     * Source database: 'datatable://name' or '$res:path'
                     */
                    source: string;
                    /**
                     * Target database: 'datatable://name' or '$res:path'
                     */
                    target: string;
                    /**
                     * Override the target database name
                     */
                    target_dbname_override?: string;
                    fork_behavior: 'schema_only' | 'schema_and_data' | 'keep_original';
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/export_pg_schema': {
        post: {
            req: {
                /**
                 * Export pg schema request
                 */
                requestBody: {
                    /**
                     * Source database: 'datatable://name' or '$res:path'
                     */
                    source: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * schema dump
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/get_datatable_full_schema': {
        post: {
            req: {
                requestBody: {
                    /**
                     * Source datatable, e.g. 'datatable://main'
                     */
                    source: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * Schema as { schema_name: { table_name: TableEditorValues } }
                 */
                200: {
                    [key: string]: {
                        [key: string]: {
                            name: string;
                            columns: Array<{
                                name: string;
                                datatype: string;
                                primary_key?: boolean;
                                default_value?: string;
                                nullable?: boolean;
                            }>;
                            foreign_keys: Array<{
                                target_table?: string;
                                columns: Array<{
                                    source_column?: string;
                                    target_column?: string;
                                }>;
                                on_delete: string;
                                on_update: string;
                                fk_constraint_name?: string;
                            }>;
                            pk_constraint_name?: string;
                        };
                    };
                };
            };
        };
    };
    '/w/{workspace}/workspaces/git_sync_enabled': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * Git sync availability status
                 */
                200: {
                    enabled?: boolean;
                    reason?: string | null;
                    max_repos?: number | null;
                    user_count?: number | null;
                    max_users?: number | null;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/edit_git_sync_config': {
        post: {
            req: {
                /**
                 * Workspace Git sync settings
                 */
                requestBody: {
                    git_sync_settings?: WorkspaceGitSyncSettings;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_git_sync_repository': {
        post: {
            req: {
                /**
                 * Git sync repository settings to add or update
                 */
                requestBody: {
                    /**
                     * The resource path of the git repository to update
                     */
                    git_repo_resource_path: string;
                    repository: GitRepositorySettings;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/delete_git_sync_repository': {
        delete: {
            req: {
                /**
                 * Git sync repository to delete
                 */
                requestBody: {
                    /**
                     * The resource path of the git repository to delete
                     */
                    git_repo_resource_path: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_deploy_ui_config': {
        post: {
            req: {
                /**
                 * Workspace deploy UI settings
                 */
                requestBody: {
                    deploy_ui_settings?: WorkspaceDeployUISettings;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/edit_default_app': {
        post: {
            req: {
                /**
                 * Workspace default app
                 */
                requestBody: {
                    default_app_path?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/default_scripts': {
        post: {
            req: {
                /**
                 * Workspace default app
                 */
                requestBody?: WorkspaceDefaultScripts;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: WorkspaceDefaultScripts;
            };
        };
    };
    '/w/{workspace}/workspaces/set_environment_variable': {
        post: {
            req: {
                /**
                 * Workspace default app
                 */
                requestBody: {
                    name: string;
                    value?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/encryption_key': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    key: string;
                };
            };
        };
        post: {
            req: {
                /**
                 * New encryption key
                 */
                requestBody: {
                    new_key: string;
                    skip_reencrypt?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/default_app': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    default_app_path?: string;
                    default_app_raw?: boolean;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/usage': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * usage
                 */
                200: number;
            };
        };
    };
    '/w/{workspace}/workspaces/used_triggers': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    http_routes_used: boolean;
                    websocket_used: boolean;
                    kafka_used: boolean;
                    nats_used: boolean;
                    postgres_used: boolean;
                    mqtt_used: boolean;
                    gcp_used: boolean;
                    azure_used: boolean;
                    sqs_used: boolean;
                    email_used: boolean;
                    nextcloud_used: boolean;
                    google_used: boolean;
                    github_used: boolean;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/protection_rules': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of protection rules
                 */
                200: Array<ProtectionRuleset>;
            };
        };
        post: {
            req: {
                /**
                 * New protection rule configuration
                 */
                requestBody: {
                    /**
                     * Unique name for the protection rule
                     */
                    name: string;
                    rules: ProtectionRules;
                    bypass_groups: RuleBypasserGroups;
                    bypass_users: RuleBypasserUsers;
                };
                workspace: string;
            };
            res: {
                /**
                 * protection rule created successfully
                 */
                200: string;
                /**
                 * rule with this name already exists
                 */
                400: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/protection_rules/{rule_name}': {
        post: {
            req: {
                /**
                 * Updated protection rule configuration
                 */
                requestBody: {
                    rules: ProtectionRules;
                    bypass_groups: RuleBypasserGroups;
                    bypass_users: RuleBypasserUsers;
                };
                /**
                 * Name of the protection rule to update
                 */
                ruleName: string;
                workspace: string;
            };
            res: {
                /**
                 * protection rule updated successfully
                 */
                200: string;
                /**
                 * protection rule not found
                 */
                404: unknown;
            };
        };
        delete: {
            req: {
                /**
                 * Name of the protection rule to delete
                 */
                ruleName: string;
                workspace: string;
            };
            res: {
                /**
                 * protection rule deleted successfully
                 */
                200: string;
                /**
                 * protection rule not found
                 */
                404: unknown;
            };
        };
    };
    '/w/{workspace}/deployment_request/eligible_deployers': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of eligible deployers
                 */
                200: Array<DeploymentRequestEligibleDeployer>;
            };
        };
    };
    '/w/{workspace}/deployment_request/open': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * the open request or null if none exists
                 */
                200: (DeploymentRequest) | null;
            };
        };
    };
    '/w/{workspace}/deployment_request': {
        post: {
            req: {
                requestBody: {
                    /**
                     * Usernames in the parent workspace. Must be admin or wm_deployers.
                     */
                    assignees: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * request created
                 */
                200: DeploymentRequest;
                /**
                 * invalid assignees
                 */
                400: unknown;
                /**
                 * a deployment request is already open for this fork
                 */
                409: unknown;
            };
        };
    };
    '/w/{workspace}/deployment_request/{id}/cancel': {
        post: {
            req: {
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * cancelled
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/deployment_request/{id}/close_merged': {
        post: {
            req: {
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * closed
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/deployment_request/{id}/comment': {
        post: {
            req: {
                id: number;
                requestBody: {
                    body: string;
                    parent_id?: number | null;
                    anchor_kind?: string | null;
                    anchor_path?: string | null;
                };
                workspace: string;
            };
            res: {
                /**
                 * comment created
                 */
                200: DeploymentRequestComment;
                /**
                 * invalid input or request closed
                 */
                400: unknown;
            };
        };
    };
    '/w/{workspace}/workspaces/log_chat': {
        post: {
            req: {
                requestBody: {
                    session_id: string;
                    provider: string;
                    model: string;
                    mode: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * logged
                 */
                204: void;
            };
        };
    };
    '/w/{workspace}/workspaces/cloud_quotas': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * cloud quota usage and limits
                 */
                200: {
                    scripts: QuotaInfo;
                    flows: QuotaInfo;
                    apps: QuotaInfo;
                    variables: QuotaInfo;
                    resources: QuotaInfo;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/prune_versions': {
        post: {
            req: {
                requestBody: {
                    resource_type: 'scripts' | 'flows' | 'apps';
                };
                workspace: string;
            };
            res: {
                /**
                 * number of pruned versions
                 */
                200: {
                    pruned: number;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/list_ws_specific': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of workspace-specific items
                 */
                200: Array<{
                    item_kind: string;
                    path: string;
                }>;
            };
        };
    };
    '/w/{workspace}/workspaces/list_ws_specific_versions': {
        get: {
            req: {
                kind: 'resource' | 'variable';
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * list of workspace ids that have a version of the item
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/shared_ui/get': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * shared UI content
                 */
                200: {
                    files: {
                        [key: string]: (string);
                    };
                    version: number;
                    edited_at: string;
                    edited_by: string;
                };
            };
        };
    };
    '/w/{workspace}/shared_ui/list': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * shared UI listing
                 */
                200: {
                    paths: Array<(string)>;
                    sizes: {
                        [key: string]: (number);
                    };
                    version: number;
                    edited_at: string;
                    edited_by: string;
                };
            };
        };
    };
    '/w/{workspace}/shared_ui/version': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * shared UI version
                 */
                200: {
                    version: number;
                };
            };
        };
    };
    '/w/{workspace}/shared_ui': {
        put: {
            req: {
                requestBody: {
                    files: {
                        [key: string]: (string);
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * updated
                 */
                200: string;
            };
        };
    };
    '/settings/refresh_custom_instance_user_pwd': {
        post: {
            res: {
                /**
                 * Success
                 */
                200: {
                    [key: string]: unknown;
                };
            };
        };
    };
    '/settings/list_custom_instance_pg_databases': {
        post: {
            res: {
                /**
                 * Statuses of all custom instance dbs
                 */
                200: {
                    [key: string]: CustomInstanceDb;
                };
            };
        };
    };
    '/settings/setup_custom_instance_pg_database/{name}': {
        post: {
            req: {
                /**
                 * The name of the database to create
                 */
                name: string;
                requestBody: {
                    tag?: CustomInstanceDbTag;
                };
            };
            res: {
                /**
                 * status
                 */
                200: CustomInstanceDb;
            };
        };
    };
    '/settings/drop_custom_instance_pg_database/{name}': {
        post: {
            req: {
                /**
                 * The name of the database to drop
                 */
                name: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/global/{key}': {
        get: {
            req: {
                key: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
        post: {
            req: {
                key: string;
                /**
                 * value set
                 */
                requestBody: {
                    value?: unknown;
                };
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings_u/ruff_config': {
        get: {
            res: {
                /**
                 * ruff.toml content (may be empty)
                 */
                200: string;
            };
        };
    };
    '/settings/local': {
        get: {
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/settings/test_smtp': {
        post: {
            req: {
                /**
                 * test smtp payload
                 */
                requestBody: {
                    to: string;
                    smtp: {
                        host: string;
                        username: string;
                        password: string;
                        port: number;
                        from: string;
                        tls_implicit: boolean;
                        disable_tls: boolean;
                    };
                };
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/test_critical_channels': {
        post: {
            req: {
                /**
                 * test critical channel payload
                 */
                requestBody: Array<{
                    email?: string;
                    slack_channel?: string;
                }>;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/critical_alerts': {
        get: {
            req: {
                acknowledged?: boolean | null;
                page?: number;
                pageSize?: number;
            };
            res: {
                /**
                 * Successfully retrieved all critical alerts
                 */
                200: {
                    alerts?: Array<CriticalAlert>;
                    /**
                     * Total number of rows matching the query.
                     */
                    total_rows?: number;
                    /**
                     * Total number of pages based on the page size.
                     */
                    total_pages?: number;
                };
            };
        };
    };
    '/settings/critical_alerts/{id}/acknowledge': {
        post: {
            req: {
                /**
                 * The ID of the critical alert to acknowledge
                 */
                id: number;
            };
            res: {
                /**
                 * Successfully acknowledged the critical alert
                 */
                200: string;
            };
        };
    };
    '/settings/critical_alerts/acknowledge_all': {
        post: {
            res: {
                /**
                 * Successfully acknowledged all unacknowledged critical alerts.
                 */
                200: string;
            };
        };
    };
    '/settings/test_license_key': {
        post: {
            req: {
                /**
                 * test license key
                 */
                requestBody: {
                    license_key: string;
                };
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/revalidate_license': {
        post: {
            res: {
                /**
                 * resolved licence state
                 */
                200: {
                    /**
                     * licence validated successfully
                     */
                    ok: boolean;
                    tier?: string;
                    edition?: string;
                    expires_at?: string | null;
                    /**
                     * instance is licence-degraded to read-only
                     */
                    read_only: boolean;
                    first_failure_at?: string | null;
                    /**
                     * this call cleared a pre-existing failure
                     */
                    recovered?: boolean;
                    tier_changed?: boolean;
                };
            };
        };
    };
    '/settings/test_object_storage_config': {
        post: {
            req: {
                /**
                 * test object storage config
                 */
                requestBody: {
                    [key: string]: unknown;
                };
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/object_storage_usage': {
        get: {
            res: {
                /**
                 * current or last storage-usage computation state
                 */
                200: {
                    running: boolean;
                    started_at: string;
                    finished_at?: string | null;
                    current_prefix?: string | null;
                    scanned_objects: number;
                    folders: Array<{
                        prefix: string;
                        size: number;
                        partial?: boolean;
                    }>;
                    error?: string | null;
                } | null;
            };
        };
        post: {
            res: {
                /**
                 * computation started
                 */
                202: string;
            };
        };
    };
    '/settings/run_log_cleanup': {
        post: {
            res: {
                /**
                 * cleanup started
                 */
                202: string;
            };
        };
    };
    '/settings/log_cleanup_status': {
        get: {
            res: {
                /**
                 * current or last log cleanup status (null if never run)
                 */
                200: {
                    running: boolean;
                    started_at: string;
                    finished_at?: string | null;
                    phase: string;
                    total_service: number;
                    processed_service: number;
                    total_jobs: number;
                    processed_jobs: number;
                    s3_deleted: number;
                    orphans_scanned: number;
                    orphans_deleted: number;
                    errors: number;
                    last_error?: string | null;
                } | null;
            };
        };
    };
    '/settings/send_stats': {
        post: {
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/restart_worker_group/{worker_group}': {
        post: {
            req: {
                /**
                 * the name of the worker group to restart
                 */
                workerGroup: string;
            };
            res: {
                /**
                 * restart signal sent
                 */
                200: string;
            };
        };
    };
    '/settings/restart_worker_pool/{worker_pool}': {
        post: {
            req: {
                /**
                 * the name of the worker pool to restart
                 */
                workerPool: string;
            };
            res: {
                /**
                 * restart signal sent
                 */
                200: string;
            };
        };
    };
    '/settings/get_stats': {
        get: {
            res: {
                /**
                 * telemetry stats JSON with signature
                 */
                200: {
                    signature?: string;
                    data?: string;
                };
            };
        };
    };
    '/settings/latest_key_renewal_attempt': {
        get: {
            res: {
                /**
                 * status
                 */
                200: {
                    result: string;
                    attempted_at: string;
                } | null;
            };
        };
    };
    '/settings/renew_license_key': {
        post: {
            req: {
                licenseKey?: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/customer_portal': {
        post: {
            req: {
                licenseKey?: string;
            };
            res: {
                /**
                 * url to portal
                 */
                200: string;
            };
        };
    };
    '/saml/test_metadata': {
        post: {
            req: {
                /**
                 * test metadata
                 */
                requestBody: string;
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/saml/metadata': {
        get: {
            res: {
                /**
                 * SAML Service Provider metadata XML document
                 */
                200: string;
            };
        };
    };
    '/saml/config': {
        get: {
            res: {
                /**
                 * current SAML configuration
                 */
                200: SamlConfig;
            };
        };
        post: {
            req: {
                /**
                 * SAML configuration
                 */
                requestBody: SamlConfigRequest;
            };
            res: {
                /**
                 * saved SAML configuration
                 */
                200: SamlConfig;
            };
        };
        delete: {
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/saml/initiate': {
        post: {
            req: {
                /**
                 * Post-login redirect target, constrained to a same-origin relative path. Held server-side against the request ID; never sent to the IdP.
                 */
                relayState?: string;
            };
            res: {
                /**
                 * redirect to the IdP's SingleSignOnService URL
                 */
                303: unknown;
            };
        };
        get: {
            req: {
                relayState?: string;
            };
            res: {
                /**
                 * redirect to the IdP's SingleSignOnService URL
                 */
                303: unknown;
            };
        };
    };
    '/saml/update_metadata': {
        post: {
            res: {
                /**
                 * refreshed SAML configuration
                 */
                200: SamlConfig;
            };
        };
    };
    '/settings/list_global': {
        get: {
            res: {
                /**
                 * list of settings
                 */
                200: Array<GlobalSetting>;
            };
        };
    };
    '/settings/runtime_usage': {
        get: {
            res: {
                /**
                 * usage counts per language
                 */
                200: Array<RuntimeUsageCount>;
            };
        };
    };
    '/settings/runtime_usage/{language}': {
        get: {
            req: {
                language: ScriptLang;
            };
            res: {
                /**
                 * usage locations for the given language
                 */
                200: Array<RuntimeUsageLocation>;
            };
        };
    };
    '/settings/instance_config': {
        get: {
            res: {
                /**
                 * full instance configuration
                 */
                200: InstanceConfig;
            };
        };
        put: {
            req: {
                /**
                 * full instance configuration to apply
                 */
                requestBody: InstanceConfig;
            };
            res: {
                /**
                 * instance config updated
                 */
                200: string;
            };
        };
    };
    '/min_keep_alive_version': {
        get: {
            res: {
                /**
                 * minimum keep-alive versions for workers and agents
                 */
                200: {
                    /**
                     * minimum version for normal workers
                     */
                    worker: string;
                    /**
                     * minimum version for agent workers
                     */
                    agent: string;
                };
            };
        };
    };
    '/.well-known/jwks.json': {
        get: {
            res: {
                /**
                 * JSON Web Key Set
                 */
                200: JwksResponse;
            };
        };
    };
    '/settings/test_secret_backend': {
        post: {
            req: {
                /**
                 * Vault settings to test
                 */
                requestBody: VaultSettings;
            };
            res: {
                /**
                 * connection successful
                 */
                200: string;
            };
        };
    };
    '/settings/migrate_secrets_to_vault': {
        post: {
            req: {
                /**
                 * Vault settings for migration target
                 */
                requestBody: VaultSettings;
            };
            res: {
                /**
                 * migration report
                 */
                200: SecretMigrationReport;
            };
        };
    };
    '/settings/migrate_secrets_to_database': {
        post: {
            req: {
                /**
                 * Vault settings for migration source
                 */
                requestBody: VaultSettings;
            };
            res: {
                /**
                 * migration report
                 */
                200: SecretMigrationReport;
            };
        };
    };
    '/settings/test_azure_kv_backend': {
        post: {
            req: {
                /**
                 * Azure Key Vault settings to test
                 */
                requestBody: AzureKeyVaultSettings;
            };
            res: {
                /**
                 * connection successful
                 */
                200: string;
            };
        };
    };
    '/settings/migrate_secrets_to_azure_kv': {
        post: {
            req: {
                /**
                 * Azure Key Vault settings for migration target
                 */
                requestBody: AzureKeyVaultSettings;
            };
            res: {
                /**
                 * migration report
                 */
                200: SecretMigrationReport;
            };
        };
    };
    '/settings/migrate_secrets_from_azure_kv': {
        post: {
            req: {
                /**
                 * Azure Key Vault settings for migration source
                 */
                requestBody: AzureKeyVaultSettings;
            };
            res: {
                /**
                 * migration report
                 */
                200: SecretMigrationReport;
            };
        };
    };
    '/settings/test_aws_sm_backend': {
        post: {
            req: {
                requestBody: AwsSecretsManagerSettings;
            };
            res: {
                /**
                 * connection test result
                 */
                200: string;
            };
        };
    };
    '/settings/migrate_secrets_to_aws_sm': {
        post: {
            req: {
                requestBody: AwsSecretsManagerSettings;
            };
            res: {
                /**
                 * migration report
                 */
                200: SecretMigrationReport;
            };
        };
    };
    '/settings/migrate_secrets_from_aws_sm': {
        post: {
            req: {
                requestBody: AwsSecretsManagerSettings;
            };
            res: {
                /**
                 * migration report
                 */
                200: SecretMigrationReport;
            };
        };
    };
    '/w/{workspace}/workspaces/get_secondary_storage_names': {
        get: {
            req: {
                /**
                 * If true, include "_default_" in the list if primary workspace storage is set
                 */
                includeDefault?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/workspaces/critical_alerts': {
        get: {
            req: {
                acknowledged?: boolean | null;
                page?: number;
                pageSize?: number;
                workspace: string;
            };
            res: {
                /**
                 * Successfully retrieved all critical alerts
                 */
                200: {
                    alerts?: Array<CriticalAlert>;
                    /**
                     * Total number of rows matching the query.
                     */
                    total_rows?: number;
                    /**
                     * Total number of pages based on the page size.
                     */
                    total_pages?: number;
                };
            };
        };
    };
    '/w/{workspace}/workspaces/critical_alerts/{id}/acknowledge': {
        post: {
            req: {
                /**
                 * The ID of the critical alert to acknowledge
                 */
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * Successfully acknowledged the critical alert
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/critical_alerts/acknowledge_all': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * Successfully acknowledged all unacknowledged critical alerts.
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/critical_alerts/mute': {
        post: {
            req: {
                /**
                 * Boolean flag to mute critical alerts.
                 */
                requestBody: {
                    /**
                     * Whether critical alerts should be muted.
                     */
                    mute_critical_alerts?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * Successfully updated mute critical alert settings.
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/workspaces/public_app_rate_limit': {
        post: {
            req: {
                /**
                 * Public app rate limit configuration
                 */
                requestBody: {
                    /**
                     * Rate limit for public app executions per minute per server. NULL or 0 to disable.
                     */
                    public_app_execution_limit_per_minute?: number;
                };
                workspace: string;
            };
            res: {
                /**
                 * Successfully updated public app rate limit settings.
                 */
                200: string;
            };
        };
    };
    '/tokens/list/scopes': {
        get: {
            res: {
                /**
                 * list of available scopes
                 */
                200: Array<ScopeDomain>;
            };
        };
    };
    '/w/{workspace}/oidc/token/{audience}': {
        post: {
            req: {
                audience: string;
                expiresIn?: number;
                workspace: string;
            };
            res: {
                /**
                 * new oidc token
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/variables/create': {
        post: {
            req: {
                /**
                 * whether the variable is already encrypted (default false)
                 */
                alreadyEncrypted?: boolean;
                /**
                 * new variable
                 */
                requestBody: CreateVariable;
                workspace: string;
            };
            res: {
                /**
                 * variable created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/variables/encrypt': {
        post: {
            req: {
                /**
                 * new variable
                 */
                requestBody: string;
                workspace: string;
            };
            res: {
                /**
                 * encrypted value
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/variables/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * variable deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/variables/delete_bulk': {
        delete: {
            req: {
                /**
                 * paths to delete
                 */
                requestBody: {
                    paths: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * deleted paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/variables/update/{path}': {
        post: {
            req: {
                /**
                 * whether the variable is already encrypted (default false)
                 */
                alreadyEncrypted?: boolean;
                path: string;
                /**
                 * updated variable
                 */
                requestBody: EditVariable;
                workspace: string;
            };
            res: {
                /**
                 * variable updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/variables/get/{path}': {
        get: {
            req: {
                /**
                 * ask to decrypt secret if this variable is secret
                 * (if not secret no effect, default: true)
                 *
                 */
                decryptSecret?: boolean;
                /**
                 * ask to include the encrypted value if secret and decrypt secret is not true (default: false)
                 *
                 */
                includeEncrypted?: boolean;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * variable
                 */
                200: ListableVariable;
            };
        };
    };
    '/w/{workspace}/variables/get_value/{path}': {
        get: {
            req: {
                /**
                 * allow getting a cached value for improved performance
                 *
                 */
                allowCache?: boolean;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * variable
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/variables/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * variable
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/variables/list': {
        get: {
            req: {
                /**
                 * broad search across multiple fields (case-insensitive substring match)
                 */
                broadFilter?: string;
                /**
                 * pattern match filter for description field (case-insensitive)
                 */
                description?: string;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * exact path match filter
                 */
                path?: string;
                /**
                 * filter variables by path prefix
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * pattern match filter for non-secret variable values (case-insensitive)
                 */
                value?: string;
                workspace: string;
            };
            res: {
                /**
                 * variable list
                 */
                200: Array<ListableVariable>;
            };
        };
    };
    '/w/{workspace}/variables/list_contextual': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * contextual variable list
                 */
                200: Array<ContextualVariable>;
            };
        };
    };
    '/w/{workspace}/oauth/connect_slack': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * redirect to Slack's OAuth authorize URL; sets a CSRF state cookie checked by connectSlackCallback
                 */
                302: unknown;
            };
        };
    };
    '/w/{workspace}/oauth/connect_slack_callback': {
        post: {
            req: {
                /**
                 * code endpoint
                 */
                requestBody: {
                    code: string;
                    state: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * confirmation message (never the bot token itself -- see handler doc comment in oauth2_ote.rs)
                 */
                200: string;
            };
        };
    };
    '/oauth/connect_slack_callback': {
        post: {
            req: {
                /**
                 * code endpoint
                 */
                requestBody: {
                    code: string;
                    state: string;
                };
            };
            res: {
                /**
                 * success message
                 */
                200: string;
            };
        };
    };
    '/oauth/connect_slack_instance': {
        post: {
            req: {
                /**
                 * connect slack at the instance level with a pre-minted bot token
                 */
                requestBody: {
                    /**
                     * xoxb-... bot token obtained at api.slack.com/apps
                     */
                    bot_token: string;
                    team_id: string;
                    team_name: string;
                };
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
    };
    '/oauth/connect_callback/{client_name}': {
        post: {
            req: {
                clientName: string;
                /**
                 * code endpoint
                 */
                requestBody: {
                    code: string;
                    state: string;
                };
            };
            res: {
                /**
                 * oauth token
                 */
                200: TokenResponse;
            };
        };
    };
    '/w/{workspace}/oauth/create_account': {
        post: {
            req: {
                /**
                 * code endpoint
                 */
                requestBody: {
                    /**
                     * OAuth refresh token. For authorization_code flow, this contains the actual refresh token. For client_credentials flow, this must be set to an empty string.
                     */
                    refresh_token: string;
                    expires_in: number;
                    client: string;
                    grant_type?: string;
                    /**
                     * OAuth client ID for resource-level credentials (client_credentials flow only)
                     */
                    cc_client_id?: string;
                    /**
                     * OAuth client secret for resource-level credentials (client_credentials flow only)
                     */
                    cc_client_secret?: string;
                    /**
                     * OAuth token URL override for resource-level authentication (client_credentials flow only)
                     */
                    cc_token_url?: string;
                    /**
                     * MCP server URL for MCP OAuth token refresh
                     */
                    mcp_server_url?: string;
                    /**
                     * OAuth scopes to use for token refresh. Overrides instance-level scopes.
                     */
                    scopes?: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * account set
                 */
                200: string;
            };
        };
    };
    '/oauth/connect_client_credentials/{client}': {
        post: {
            req: {
                /**
                 * OAuth client name
                 */
                client: string;
                /**
                 * client credentials flow parameters
                 */
                requestBody: {
                    scopes?: Array<(string)>;
                    /**
                     * OAuth client ID for resource-level authentication
                     */
                    cc_client_id: string;
                    /**
                     * OAuth client secret for resource-level authentication
                     */
                    cc_client_secret: string;
                    /**
                     * OAuth token URL override for resource-level authentication
                     */
                    cc_token_url?: string;
                };
            };
            res: {
                /**
                 * OAuth token response
                 */
                200: TokenResponse;
            };
        };
    };
    '/w/{workspace}/oauth/refresh_token/{id}': {
        post: {
            req: {
                id: number;
                /**
                 * variable path
                 */
                requestBody: {
                    path: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * token refreshed
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/oauth/disconnect/{id}': {
        post: {
            req: {
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * disconnected client
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/oauth/disconnect_slack': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * disconnected slack
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/oauth/disconnect_teams': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * disconnected teams
                 */
                200: string;
            };
        };
    };
    '/oauth/list_logins': {
        get: {
            res: {
                /**
                 * list of oauth and saml login clients
                 */
                200: {
                    oauth: Array<{
                        type: string;
                        display_name?: string;
                    }>;
                    saml?: string;
                    /**
                     * provider type to auto-redirect to on login (oauth key or "saml")
                     */
                    auto_login?: string;
                };
            };
        };
    };
    '/oauth/list_connects': {
        get: {
            res: {
                /**
                 * list of oauth connects clients
                 */
                200: Array<(string)>;
            };
        };
    };
    '/oauth/get_connect/{client}': {
        get: {
            req: {
                /**
                 * client name
                 */
                client: string;
            };
            res: {
                /**
                 * get
                 */
                200: {
                    extra_params?: {
                        [key: string]: unknown;
                    };
                    scopes?: Array<(string)>;
                    grant_types?: Array<(string)>;
                };
            };
        };
    };
    '/teams/activities': {
        post: {
            req: {
                requestBody: {
                    /**
                     * The ID of the Teams conversation/activity
                     */
                    conversation_id: string;
                    /**
                     * Used for styling the card conditionally
                     */
                    success?: boolean;
                    /**
                     * The message text to be sent in the Teams card
                     */
                    text: string;
                    /**
                     * The card block to be sent in the Teams card
                     */
                    card_block?: {
                        [key: string]: unknown;
                    };
                };
            };
            res: {
                /**
                 * Activity processed successfully
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/resources/create': {
        post: {
            req: {
                /**
                 * new resource
                 */
                requestBody: CreateResource;
                /**
                 * update the resource if it already exists (default false)
                 */
                updateIfExists?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * resource created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/resources/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * resource deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/resources/delete_bulk': {
        delete: {
            req: {
                /**
                 * paths to delete
                 */
                requestBody: {
                    paths: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * deleted paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/resources/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated resource
                 */
                requestBody: EditResource;
                workspace: string;
            };
            res: {
                /**
                 * resource updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/resources/update_value/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated resource
                 */
                requestBody: {
                    value?: unknown;
                };
                workspace: string;
            };
            res: {
                /**
                 * resource value updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/resources/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * resource
                 */
                200: Resource;
            };
        };
    };
    '/w/{workspace}/resources/get_value_interpolated/{path}': {
        get: {
            req: {
                /**
                 * allow getting a cached value for improved performance
                 */
                allowCache?: boolean;
                /**
                 * job id
                 */
                jobId?: string;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * resource value
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/resources/get_value/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * resource value
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/resources/git_commit_hash/{path}': {
        get: {
            req: {
                gitSshIdentity?: string;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * git commit hash
                 */
                200: {
                    /**
                     * Latest commit hash from git ls-remote
                     */
                    commit_hash: string;
                };
            };
        };
    };
    '/w/{workspace}/resources/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * does resource exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/resources/list': {
        get: {
            req: {
                /**
                 * broad search across multiple fields (case-insensitive substring match)
                 */
                broadFilter?: string;
                /**
                 * pattern match filter for description field (case-insensitive)
                 */
                description?: string;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * exact path match filter
                 */
                path?: string;
                /**
                 * filter resources by path prefix
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * resource_types to list from, separated by ',',
                 */
                resourceType?: string;
                /**
                 * resource_types to not list from, separated by ',',
                 */
                resourceTypeExclude?: string;
                /**
                 * JSONB subset match filter using base64 encoded JSON
                 */
                value?: string;
                workspace: string;
            };
            res: {
                /**
                 * resource list
                 */
                200: Array<ListableResource>;
            };
        };
    };
    '/w/{workspace}/resources/list_search': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * resource list
                 */
                200: Array<{
                    path: string;
                    value: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/resources/mcp_tools/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * list of MCP tools
                 */
                200: Array<{
                    name: string;
                    description?: string;
                    parameters: {
                        [key: string]: unknown;
                    };
                }>;
            };
        };
    };
    '/w/{workspace}/resources/list_names/{name}': {
        get: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * resource list names
                 */
                200: Array<{
                    name: string;
                    path: string;
                }>;
            };
        };
    };
    '/w/{workspace}/resources/type/create': {
        post: {
            req: {
                /**
                 * new resource_type
                 */
                requestBody: ResourceType;
                workspace: string;
            };
            res: {
                /**
                 * resource_type created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/resources/file_resource_type_to_file_ext_map': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * map from resource type to file resource info
                 */
                200: {
                    [key: string]: {
                        format_extension?: string | null;
                        is_fileset?: boolean;
                    };
                };
            };
        };
    };
    '/w/{workspace}/resources/type/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * resource_type deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/resources/type/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated resource_type
                 */
                requestBody: EditResourceType;
                workspace: string;
            };
            res: {
                /**
                 * resource_type updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/resources/type/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * resource_type deleted
                 */
                200: ResourceType;
            };
        };
    };
    '/w/{workspace}/resources/type/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * does resource_type exist
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/resources/type/list': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * resource_type list
                 */
                200: Array<ResourceType>;
            };
        };
    };
    '/w/{workspace}/resources/type/listnames': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * resource_type list
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/embeddings/query_resource_types': {
        get: {
            req: {
                /**
                 * query limit
                 */
                limit?: number;
                /**
                 * query text
                 */
                text: string;
                workspace: string;
            };
            res: {
                /**
                 * resource type details
                 */
                200: Array<{
                    name: string;
                    score: number;
                    schema?: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/connections/create': {
        post: {
            req: {
                /**
                 * new connection
                 */
                requestBody: CreateResource;
                /**
                 * update the connection if it already exists (default false)
                 */
                updateIfExists?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * connection created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/connections/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * connection deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/connections/delete_bulk': {
        delete: {
            req: {
                /**
                 * paths to delete
                 */
                requestBody: {
                    paths: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * deleted paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/connections/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated connection
                 */
                requestBody: EditResource;
                workspace: string;
            };
            res: {
                /**
                 * connection updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/connections/update_value/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated connection
                 */
                requestBody: {
                    value?: unknown;
                };
                workspace: string;
            };
            res: {
                /**
                 * connection value updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/connections/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * connection
                 */
                200: Resource;
            };
        };
    };
    '/w/{workspace}/connections/get_value_interpolated/{path}': {
        get: {
            req: {
                /**
                 * allow getting a cached value for improved performance
                 */
                allowCache?: boolean;
                /**
                 * job id
                 */
                jobId?: string;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * connection value
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/connections/get_value/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * connection value
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/connections/git_commit_hash/{path}': {
        get: {
            req: {
                gitSshIdentity?: string;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * git commit hash
                 */
                200: {
                    /**
                     * Latest commit hash from git ls-remote
                     */
                    commit_hash: string;
                };
            };
        };
    };
    '/w/{workspace}/connections/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * does connection exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/connections/list': {
        get: {
            req: {
                /**
                 * broad search across multiple fields (case-insensitive substring match)
                 */
                broadFilter?: string;
                /**
                 * connection_types to list from, separated by ',',
                 */
                connectionType?: string;
                /**
                 * connection_types to not list from, separated by ',',
                 */
                connectionTypeExclude?: string;
                /**
                 * pattern match filter for description field (case-insensitive)
                 */
                description?: string;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * exact path match filter
                 */
                path?: string;
                /**
                 * filter connections by path prefix
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * JSONB subset match filter using base64 encoded JSON
                 */
                value?: string;
                workspace: string;
            };
            res: {
                /**
                 * connection list
                 */
                200: Array<ListableResource>;
            };
        };
    };
    '/w/{workspace}/connections/list_search': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * connection list
                 */
                200: Array<{
                    path: string;
                    value: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/connections/mcp_tools/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * list of MCP tools
                 */
                200: Array<{
                    name: string;
                    description?: string;
                    parameters: {
                        [key: string]: unknown;
                    };
                }>;
            };
        };
    };
    '/w/{workspace}/connections/list_names/{name}': {
        get: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * connection list names
                 */
                200: Array<{
                    name: string;
                    path: string;
                }>;
            };
        };
    };
    '/w/{workspace}/connections/type/create': {
        post: {
            req: {
                /**
                 * new connection_type
                 */
                requestBody: ResourceType;
                workspace: string;
            };
            res: {
                /**
                 * connection_type created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/connections/file_connection_type_to_file_ext_map': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * map from connection type to file connection info
                 */
                200: {
                    [key: string]: {
                        format_extension?: string | null;
                        is_fileset?: boolean;
                    };
                };
            };
        };
    };
    '/w/{workspace}/connections/type/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * connection_type deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/connections/type/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated connection_type
                 */
                requestBody: EditResourceType;
                workspace: string;
            };
            res: {
                /**
                 * connection_type updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/connections/type/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * connection_type deleted
                 */
                200: ResourceType;
            };
        };
    };
    '/w/{workspace}/connections/type/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * does connection_type exist
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/connections/type/list': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * connection_type list
                 */
                200: Array<ResourceType>;
            };
        };
    };
    '/w/{workspace}/connections/type/listnames': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * connection_type list
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/npm_proxy/metadata/{package}': {
        get: {
            req: {
                /**
                 * npm package name
                 */
                _package: string;
                workspace: string;
            };
            res: {
                /**
                 * package metadata
                 */
                200: {
                    tags?: {
                        [key: string]: (string);
                    };
                    versions?: Array<(string)>;
                };
            };
        };
    };
    '/w/{workspace}/npm_proxy/resolve/{package}': {
        get: {
            req: {
                /**
                 * npm package name
                 */
                _package: string;
                /**
                 * version tag or reference
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * resolved version
                 */
                200: {
                    version?: string | null;
                };
            };
        };
    };
    '/w/{workspace}/npm_proxy/filetree/{package}/{version}': {
        get: {
            req: {
                /**
                 * npm package name
                 */
                _package: string;
                /**
                 * package version
                 */
                version: string;
                workspace: string;
            };
            res: {
                /**
                 * package file tree
                 */
                200: {
                    default?: string;
                    files?: Array<{
                        name?: string;
                    }>;
                };
            };
        };
    };
    '/w/{workspace}/npm_proxy/file/{package}/{version}/{filepath}': {
        get: {
            req: {
                /**
                 * npm package name
                 */
                _package: string;
                /**
                 * file path within package
                 */
                filepath: string;
                /**
                 * package version
                 */
                version: string;
                workspace: string;
            };
            res: {
                /**
                 * file content
                 */
                200: string;
            };
        };
    };
    '/integrations/hub/list': {
        get: {
            req: {
                /**
                 * query integrations kind
                 */
                kind?: string;
            };
            res: {
                /**
                 * integrations details
                 */
                200: Array<{
                    name: string;
                }>;
            };
        };
    };
    '/flows/hub/list': {
        get: {
            res: {
                /**
                 * hub flows list
                 */
                200: {
                    flows?: Array<{
                        id: number;
                        flow_id: number;
                        summary: string;
                        apps: Array<(string)>;
                        approved: boolean;
                        votes: number;
                    }>;
                };
            };
        };
    };
    '/flows/hub/get/{id}': {
        get: {
            req: {
                id: number;
            };
            res: {
                /**
                 * flow
                 */
                200: {
                    flow?: OpenFlow;
                };
            };
        };
    };
    '/w/{workspace}/flows/list_paths': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of flow paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/flows/list_search': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * flow list
                 */
                200: Array<{
                    path: string;
                    value: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/flows/list': {
        get: {
            req: {
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * (default regardless)
                 * If true, show only flows with dedicated_worker enabled.
                 * If false, show only flows with dedicated_worker disabled.
                 *
                 */
                dedicatedWorker?: boolean;
                /**
                 * (default false)
                 * include items that have no deployed version
                 *
                 */
                includeDraftOnly?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * mask to filter exact matching path
                 */
                pathExact?: string;
                /**
                 * mask to filter matching starting path
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * (default false)
                 * show only the archived files.
                 * when multiple archived hash share the same path, only the ones with the latest create_at
                 * are displayed.
                 *
                 */
                showArchived?: boolean;
                /**
                 * (default false)
                 * show only the starred items
                 *
                 */
                starredOnly?: boolean;
                /**
                 * (default false)
                 * include deployment message
                 *
                 */
                withDeploymentMsg?: boolean;
                /**
                 * (default false)
                 * If true, the description field will be omitted from the response.
                 *
                 */
                withoutDescription?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * All flow
                 */
                200: Array<(Flow & {
                    has_draft?: boolean;
                    draft_only?: boolean;
                })>;
            };
        };
    };
    '/w/{workspace}/flows/history/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * Flow history
                 */
                200: Array<FlowVersion>;
            };
        };
    };
    '/w/{workspace}/flows/get_latest_version/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * Flow version
                 */
                200: FlowVersion;
            };
        };
    };
    '/w/{workspace}/flows/list_paths_from_workspace_runnable/{runnable_kind}/{path}': {
        get: {
            req: {
                matchPathStart?: boolean;
                path: string;
                runnableKind: 'script' | 'flow';
                workspace: string;
            };
            res: {
                /**
                 * list of flow paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/flows/get/v/{version}': {
        get: {
            req: {
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * flow details
                 */
                200: Flow;
            };
        };
    };
    '/w/{workspace}/flows/history_update/v/{version}': {
        post: {
            req: {
                /**
                 * Flow deployment message
                 */
                requestBody: {
                    deployment_msg: string;
                };
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * success
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/flows/get/{path}': {
        get: {
            req: {
                path: string;
                withStarredInfo?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * flow details
                 */
                200: Flow;
            };
        };
    };
    '/w/{workspace}/flows/deployment_status/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * flow status
                 */
                200: {
                    lock_error_logs?: string;
                    job_id?: string;
                };
            };
        };
    };
    '/w/{workspace}/flows/get_triggers_count/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * triggers count
                 */
                200: TriggersCount;
            };
        };
    };
    '/w/{workspace}/flows/list_tokens/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * tokens list
                 */
                200: Array<TruncatedToken>;
            };
        };
    };
    '/w/{workspace}/flows/toggle_workspace_error_handler/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * Workspace error handler enabled
                 */
                requestBody: {
                    muted?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * error handler toggled
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/flows/get/draft/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * flow details with draft
                 */
                200: Flow & {
                    draft?: Flow;
                };
            };
        };
    };
    '/w/{workspace}/flows/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * flow details
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/flows/create': {
        post: {
            req: {
                /**
                 * Partially filled flow
                 */
                requestBody: OpenFlowWPath & {
                    draft_only?: boolean;
                    deployment_message?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * flow created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/flows/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * Partially filled flow
                 */
                requestBody: OpenFlowWPath & {
                    deployment_message?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * flow updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/flows/archive/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * archiveFlow
                 */
                requestBody: {
                    archived?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * flow archived
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/flows/delete/{path}': {
        delete: {
            req: {
                /**
                 * keep captures
                 */
                keepCaptures?: boolean;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * flow delete
                 */
                200: string;
            };
        };
    };
    '/apps/hub/list': {
        get: {
            res: {
                /**
                 * hub apps list
                 */
                200: {
                    apps?: Array<{
                        id: number;
                        app_id: number;
                        summary: string;
                        apps: Array<(string)>;
                        approved: boolean;
                        votes: number;
                    }>;
                };
            };
        };
    };
    '/apps/hub/get/{id}': {
        get: {
            req: {
                id: number;
            };
            res: {
                /**
                 * app
                 */
                200: {
                    app: {
                        summary: string;
                        value: unknown;
                    };
                };
            };
        };
    };
    '/apps/hub/get_raw/{id}': {
        get: {
            req: {
                id: number;
            };
            res: {
                /**
                 * raw app
                 */
                200: {
                    app: {
                        summary: string;
                        value: unknown;
                    };
                };
            };
        };
    };
    '/apps_u/public_app_by_custom_path/{custom_path}': {
        get: {
            req: {
                customPath: string;
            };
            res: {
                /**
                 * app details
                 */
                200: AppWithLastVersion & {
                    workspace_id?: string;
                };
            };
        };
    };
    '/w/{workspace}/apps/get_data/v/{secretWithExtension}': {
        get: {
            req: {
                secretWithExtension: string;
                workspace: string;
            };
            res: {
                /**
                 * app details
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps/list_search': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * app list
                 */
                200: Array<{
                    path: string;
                    value: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/apps/list': {
        get: {
            req: {
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * (default false)
                 * include items that have no deployed version
                 *
                 */
                includeDraftOnly?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * mask to filter exact matching path
                 */
                pathExact?: string;
                /**
                 * mask to filter matching starting path
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * (default false)
                 * show only the starred items
                 *
                 */
                starredOnly?: boolean;
                /**
                 * (default false)
                 * include deployment message
                 *
                 */
                withDeploymentMsg?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * All apps
                 */
                200: Array<ListableApp>;
            };
        };
    };
    '/w/{workspace}/apps/create': {
        post: {
            req: {
                /**
                 * new app
                 */
                requestBody: {
                    path: string;
                    value: unknown;
                    summary: string;
                    policy: Policy;
                    draft_only?: boolean;
                    deployment_message?: string;
                    custom_path?: string;
                    /**
                     * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
                     */
                    preserve_on_behalf_of?: boolean;
                    labels?: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * app created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/apps/create_raw': {
        post: {
            req: {
                /**
                 * new app
                 */
                formData: {
                    app?: {
                        path: string;
                        value: unknown;
                        summary: string;
                        policy: Policy;
                        draft_only?: boolean;
                        deployment_message?: string;
                        custom_path?: string;
                        /**
                         * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
                         */
                        preserve_on_behalf_of?: boolean;
                        labels?: Array<(string)>;
                    };
                    js?: string;
                    css?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * app created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/apps/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/apps/get/p/{path}': {
        get: {
            req: {
                path: string;
                withStarredInfo?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * app details
                 */
                200: AppWithLastVersion;
            };
        };
    };
    '/w/{workspace}/apps/get/lite/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app lite details
                 */
                200: AppWithLastVersion;
            };
        };
    };
    '/w/{workspace}/apps/get/draft/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app details with draft
                 */
                200: AppWithLastVersionWDraft;
            };
        };
    };
    '/w/{workspace}/apps/history/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app history
                 */
                200: Array<AppHistory>;
            };
        };
    };
    '/w/{workspace}/apps/get_latest_version/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * App version
                 */
                200: AppHistory;
            };
        };
    };
    '/w/{workspace}/apps/list_paths_from_workspace_runnable/{runnable_kind}/{path}': {
        get: {
            req: {
                path: string;
                runnableKind: 'script' | 'flow';
                workspace: string;
            };
            res: {
                /**
                 * list of app paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/apps/history_update/a/{id}/v/{version}': {
        post: {
            req: {
                id: number;
                /**
                 * App deployment message
                 */
                requestBody: {
                    deployment_msg?: string;
                };
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * success
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps_u/public_app/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app details
                 */
                200: AppWithLastVersion;
            };
        };
    };
    '/w/{workspace}/apps_u/public_resource/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * resource value
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/apps/secret_of/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app secret
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps/secret_of_latest_version/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app secret
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps/get/v/{id}': {
        get: {
            req: {
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * app details
                 */
                200: AppWithLastVersion;
            };
        };
    };
    '/w/{workspace}/apps/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * update app
                 */
                requestBody: {
                    path?: string;
                    summary?: string;
                    value?: unknown;
                    policy?: Policy;
                    deployment_message?: string;
                    custom_path?: string;
                    /**
                     * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
                     */
                    preserve_on_behalf_of?: boolean;
                    labels?: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * app updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps/update_raw/{path}': {
        post: {
            req: {
                /**
                 * update app
                 */
                formData: {
                    app?: {
                        path?: string;
                        summary?: string;
                        value?: unknown;
                        policy?: Policy;
                        deployment_message?: string;
                        custom_path?: string;
                        /**
                         * When true and the caller is a member of the 'wm_deployers' group, preserves the original on_behalf_of value in the policy instead of overwriting it.
                         */
                        preserve_on_behalf_of?: boolean;
                        labels?: Array<(string)>;
                    };
                    js?: string;
                    css?: string;
                };
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * app updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps/custom_path_exists/{custom_path}': {
        get: {
            req: {
                customPath: string;
                workspace: string;
            };
            res: {
                /**
                 * custom path exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/apps/sign_s3_objects': {
        post: {
            req: {
                /**
                 * s3 objects to sign
                 */
                requestBody: {
                    s3_objects: Array<S3Object>;
                };
                workspace: string;
            };
            res: {
                /**
                 * signed s3 objects
                 */
                200: Array<S3Object>;
            };
        };
    };
    '/w/{workspace}/apps_u/execute_component/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * update app
                 */
                requestBody: {
                    component: string;
                    path?: string;
                    version?: number;
                    args: unknown;
                    raw_code?: {
                        content: string;
                        language: string;
                        path?: string;
                        lock?: string;
                        cache_ttl?: number;
                        tag?: string;
                    };
                    id?: number;
                    force_viewer_static_fields?: {
                        [key: string]: unknown;
                    };
                    force_viewer_one_of_fields?: {
                        [key: string]: unknown;
                    };
                    force_viewer_allow_user_resources?: Array<(string)>;
                    force_viewer_sensitive_inputs?: Array<(string)>;
                    force_viewer_delete_after_secs?: number;
                    /**
                     * Runnable query parameters
                     */
                    run_query_params?: {
                        [key: string]: unknown;
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * job uuid
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/apps_u/upload_s3_file/{path}': {
        post: {
            req: {
                contentDisposition?: string;
                contentType?: string;
                fileExtension?: string;
                fileKey?: string;
                path: string;
                /**
                 * File content
                 */
                requestBody: (Blob | File);
                resourceType?: string;
                s3ResourcePath?: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * file uploaded
                 */
                200: {
                    file_key: string;
                    delete_token: string;
                };
            };
        };
    };
    '/w/{workspace}/apps_u/delete_s3_file': {
        delete: {
            req: {
                deleteToken: string;
                workspace: string;
            };
            res: {
                /**
                 * file deleted
                 */
                200: string;
            };
        };
    };
    '/scripts/hub/get/{path}': {
        get: {
            req: {
                path: string;
            };
            res: {
                /**
                 * script details
                 */
                200: string;
            };
        };
    };
    '/scripts/hub/get_full/{path}': {
        get: {
            req: {
                path: string;
            };
            res: {
                /**
                 * script details
                 */
                200: {
                    content: string;
                    lockfile?: string;
                    schema?: unknown;
                    language: string;
                    summary?: string;
                };
            };
        };
    };
    '/scripts/hub/pick/{path}': {
        get: {
            req: {
                path: string;
            };
            res: {
                /**
                 * script pick recorded
                 */
                200: {
                    success: boolean;
                };
            };
        };
    };
    '/scripts/hub/top': {
        get: {
            req: {
                /**
                 * query scripts app
                 */
                app?: string;
                /**
                 * query scripts kind
                 */
                kind?: string;
                /**
                 * query limit
                 */
                limit?: number;
            };
            res: {
                /**
                 * hub scripts list
                 */
                200: {
                    asks?: Array<{
                        id: number;
                        ask_id: number;
                        summary: string;
                        app: string;
                        version_id: number;
                        kind: HubScriptKind;
                        votes: number;
                        views: number;
                    }>;
                };
            };
        };
    };
    '/embeddings/query_hub_scripts': {
        get: {
            req: {
                /**
                 * query scripts app
                 */
                app?: string;
                /**
                 * query scripts kind
                 */
                kind?: string;
                /**
                 * query limit
                 */
                limit?: number;
                /**
                 * query text
                 */
                text: string;
            };
            res: {
                /**
                 * script details
                 */
                200: Array<{
                    ask_id: number;
                    id: number;
                    version_id: number;
                    summary: string;
                    app: string;
                    kind: HubScriptKind;
                    score: number;
                }>;
            };
        };
    };
    '/w/{workspace}/scripts/list_search': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * script list
                 */
                200: Array<{
                    path: string;
                    content: string;
                }>;
            };
        };
    };
    '/w/{workspace}/scripts/list': {
        get: {
            req: {
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * (default regardless)
                 * If true, show only scripts with dedicated_worker enabled.
                 * If false, show only scripts with dedicated_worker disabled.
                 *
                 */
                dedicatedWorker?: boolean;
                /**
                 * mask to filter scripts whom first direct parent has exact hash
                 */
                firstParentHash?: string;
                /**
                 * (default false)
                 * include scripts that have no deployed version
                 *
                 */
                includeDraftOnly?: boolean;
                /**
                 * (default false)
                 * include scripts without an exported main function
                 *
                 */
                includeWithoutMain?: boolean;
                /**
                 * (default regardless)
                 * if true show only the templates
                 * if false show only the non templates
                 * if not defined, show all regardless of if the script is a template
                 *
                 */
                isTemplate?: boolean;
                /**
                 * (default regardless)
                 * script kinds to filter, split by comma
                 *
                 */
                kinds?: string;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * Filter to only include scripts written in the given languages.
                 * Accepts multiple values as a comma-separated list.
                 *
                 */
                languages?: string;
                /**
                 * mask to filter scripts whom last parent in the chain has exact hash.
                 * Beware that each script stores only a limited number of parents. Hence
                 * the last parent hash for a script is not necessarily its top-most parent.
                 * To find the top-most parent you will have to jump from last to last hash
                 * until finding the parent
                 *
                 */
                lastParentHash?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * is the hash present in the array of stored parent hashes for this script.
                 * The same warning applies than for last_parent_hash. A script only store a
                 * limited number of direct parent
                 *
                 */
                parentHash?: string;
                /**
                 * mask to filter exact matching path
                 */
                pathExact?: string;
                /**
                 * mask to filter matching starting path
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * (default false)
                 * show only the archived files.
                 * when multiple archived hash share the same path, only the ones with the latest create_at
                 * are
                 * ed.
                 *
                 */
                showArchived?: boolean;
                /**
                 * (default false)
                 * show only the starred items
                 *
                 */
                starredOnly?: boolean;
                /**
                 * (default false)
                 * include deployment message
                 *
                 */
                withDeploymentMsg?: boolean;
                /**
                 * (default false)
                 * If true, the description field will be omitted from the response.
                 *
                 */
                withoutDescription?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * All scripts
                 */
                200: Array<Script>;
            };
        };
    };
    '/w/{workspace}/scripts/list_paths': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of script paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/scripts/create': {
        post: {
            req: {
                /**
                 * Partially filled script
                 */
                requestBody: NewScript;
                workspace: string;
            };
            res: {
                /**
                 * script created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/scripts/toggle_workspace_error_handler/p/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * Workspace error handler enabled
                 */
                requestBody: {
                    muted?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * error handler toggled
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/scripts/archive/p/{path}': {
        post: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * script archived
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/scripts/archive/h/{hash}': {
        post: {
            req: {
                hash: string;
                workspace: string;
            };
            res: {
                /**
                 * script details
                 */
                200: Script;
            };
        };
    };
    '/w/{workspace}/scripts/delete/h/{hash}': {
        post: {
            req: {
                hash: string;
                workspace: string;
            };
            res: {
                /**
                 * script details
                 */
                200: Script;
            };
        };
    };
    '/w/{workspace}/scripts/delete/p/{path}': {
        post: {
            req: {
                /**
                 * keep captures
                 */
                keepCaptures?: boolean;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * script path
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/scripts/delete_bulk': {
        delete: {
            req: {
                /**
                 * paths to delete
                 */
                requestBody: {
                    paths: Array<(string)>;
                };
                workspace: string;
            };
            res: {
                /**
                 * deleted paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/scripts/get/p/{path}': {
        get: {
            req: {
                path: string;
                withStarredInfo?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * script details
                 */
                200: Script;
            };
        };
    };
    '/w/{workspace}/scripts/get_triggers_count/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * triggers count
                 */
                200: TriggersCount;
            };
        };
    };
    '/w/{workspace}/scripts/list_tokens/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * tokens list
                 */
                200: Array<TruncatedToken>;
            };
        };
    };
    '/w/{workspace}/scripts/get/draft/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * script details
                 */
                200: NewScriptWithDraft;
            };
        };
    };
    '/w/{workspace}/scripts/history/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * script history
                 */
                200: Array<ScriptHistory>;
            };
        };
    };
    '/w/{workspace}/scripts/list_paths_from_workspace_runnable/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * list of script paths
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/scripts/get_latest_version/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * Script version/hash
                 */
                200: ScriptHistory;
            };
        };
    };
    '/w/{workspace}/scripts/history_update/h/{hash}/p/{path}': {
        post: {
            req: {
                hash: string;
                path: string;
                /**
                 * Script deployment message
                 */
                requestBody: {
                    deployment_msg?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * success
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/scripts/list_dedicated_with_deps': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of dedicated scripts with their workspace dependency names
                 */
                200: Array<{
                    path: string;
                    language: 'python3' | 'deno' | 'go' | 'bash' | 'powershell' | 'postgresql' | 'mysql' | 'bigquery' | 'snowflake' | 'mssql' | 'graphql' | 'nativets' | 'bun' | 'bunnative' | 'php' | 'rust' | 'ansible' | 'csharp' | 'oracledb' | 'duckdb' | 'java' | 'ruby' | 'mongodb' | 'groovy' | 'kotlin' | 'dart';
                    workspace_dep_names: Array<(string)>;
                }>;
            };
        };
    };
    '/w/{workspace}/scripts/raw/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * script content
                 */
                200: string;
            };
        };
    };
    '/scripts_u/tokened_raw/{workspace}/{token}/{path}': {
        get: {
            req: {
                path: string;
                token: string;
                workspace: string;
            };
            res: {
                /**
                 * script content
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/scripts/exists/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * does it exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/scripts/get/h/{hash}': {
        get: {
            req: {
                authed?: boolean;
                hash: string;
                withStarredInfo?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * script details
                 */
                200: Script;
            };
        };
    };
    '/w/{workspace}/scripts/raw/h/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * script content
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/scripts/deployment_status/h/{hash}': {
        get: {
            req: {
                hash: string;
                workspace: string;
            };
            res: {
                /**
                 * script details
                 */
                200: {
                    lock?: string;
                    lock_error_logs?: string;
                    job_id?: string;
                };
            };
        };
    };
    '/w/{workspace}/scripts/ci_test_results/{kind}/{path}': {
        get: {
            req: {
                kind: 'script' | 'flow' | 'resource';
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * CI test results
                 */
                200: Array<CiTestResult>;
            };
        };
    };
    '/w/{workspace}/scripts/ci_test_results_batch': {
        post: {
            req: {
                requestBody: {
                    items: Array<{
                        path: string;
                        kind: 'script' | 'flow' | 'resource';
                    }>;
                };
                workspace: string;
            };
            res: {
                /**
                 * CI test results by item key
                 */
                200: {
                    [key: string]: Array<CiTestResult>;
                };
            };
        };
    };
    '/w/{workspace}/scripts/raw_temp/store': {
        post: {
            req: {
                /**
                 * script content to store
                 */
                requestBody: string;
                workspace: string;
            };
            res: {
                /**
                 * hash of stored content
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/scripts/raw_temp/diff': {
        post: {
            req: {
                /**
                 * scripts and workspace deps to diff against deployed versions
                 */
                requestBody: {
                    /**
                     * map of script path to SHA256 content hash
                     */
                    scripts: {
                        [key: string]: (string);
                    };
                    /**
                     * workspace dependencies to diff
                     */
                    workspace_deps?: Array<{
                        /**
                         * CLI path (e.g. dependencies/package.json)
                         */
                        path: string;
                        language: ScriptLang;
                        /**
                         * named workspace dependency (null for default)
                         */
                        name?: string;
                        /**
                         * SHA256 content hash
                         */
                        hash: string;
                    }>;
                };
                workspace: string;
            };
            res: {
                /**
                 * list of paths that differ from deployed versions
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/drafts/create': {
        post: {
            req: {
                requestBody: {
                    path: string;
                    typ: 'flow' | 'script' | 'app' | 'bpmn' | 'dmn_decision';
                    value?: unknown;
                };
                workspace: string;
            };
            res: {
                /**
                 * draft created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/drafts/delete/{kind}/{path}': {
        delete: {
            req: {
                kind: 'script' | 'flow' | 'app';
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * draft deleted
                 */
                200: string;
            };
        };
    };
    '/workers/custom_tags': {
        get: {
            req: {
                showWorkspaceRestriction?: boolean;
            };
            res: {
                /**
                 * list of custom tags
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/workers/custom_tags': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of custom tags for workspace
                 */
                200: Array<(string)>;
            };
        };
    };
    '/workers/get_default_tags': {
        get: {
            res: {
                /**
                 * list of default tags
                 */
                200: Array<(string)>;
            };
        };
    };
    '/workers/is_default_tags_per_workspace': {
        get: {
            res: {
                /**
                 * is the default tags per workspace
                 */
                200: boolean;
            };
        };
    };
    '/workers/list': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * number of seconds the worker must have had a last ping more recent of (default to 300)
                 */
                pingSince?: number;
            };
            res: {
                /**
                 * a list of workers
                 */
                200: Array<WorkerPing>;
            };
        };
    };
    '/workers/exists_workers_with_tags': {
        get: {
            req: {
                /**
                 * comma separated list of tags
                 */
                tags: string;
                /**
                 * workspace to filter tags visibility (required when TAGS_ARE_SENSITIVE is enabled for non-superadmins)
                 */
                workspace?: string;
            };
            res: {
                /**
                 * map of tags to whether at least one worker with the tag exists
                 */
                200: {
                    [key: string]: (boolean);
                };
            };
        };
    };
    '/workers/queue_metrics': {
        get: {
            res: {
                /**
                 * metrics
                 */
                200: Array<{
                    id: string;
                    values: Array<{
                        created_at: string;
                        value: number;
                    }>;
                }>;
            };
        };
    };
    '/workers/queue_counts': {
        get: {
            res: {
                /**
                 * queue counts
                 */
                200: {
                    [key: string]: (number);
                };
            };
        };
    };
    '/workers/queue_running_counts': {
        get: {
            res: {
                /**
                 * queue running counts
                 */
                200: {
                    [key: string]: (number);
                };
            };
        };
    };
    '/w/{workspace}/workspace_dependencies/create': {
        post: {
            req: {
                /**
                 * New workspace dependencies
                 */
                requestBody: NewWorkspaceDependencies;
                workspace: string;
            };
            res: {
                /**
                 * workspace dependencies created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/workspace_dependencies/archive/{language}': {
        post: {
            req: {
                language: ScriptLang;
                name?: string;
                workspace: string;
            };
            res: {
                /**
                 * result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspace_dependencies/delete/{language}': {
        post: {
            req: {
                language: ScriptLang;
                name?: string;
                workspace: string;
            };
            res: {
                /**
                 * result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/workspace_dependencies/list': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * All workspace dependencies
                 */
                200: Array<WorkspaceDependencies>;
            };
        };
    };
    '/w/{workspace}/workspace_dependencies/get_latest/{language}': {
        get: {
            req: {
                language: ScriptLang;
                name?: string;
                workspace: string;
            };
            res: {
                /**
                 * Latest workspace dependencies
                 */
                200: WorkspaceDependencies;
            };
        };
    };
    '/w/{workspace}/jobs/list_selected_job_groups': {
        post: {
            req: {
                /**
                 * script args
                 */
                requestBody: Array<(string)>;
                workspace: string;
            };
            res: {
                /**
                 * result
                 */
                200: Array<{
                    kind: 'script' | 'flow';
                    script_path: string;
                    latest_schema: {
                        [key: string]: unknown;
                    };
                    schemas: Array<{
                        schema: {
                            [key: string]: unknown;
                        };
                        script_hash: string;
                        job_ids: Array<(string)>;
                    }>;
                }>;
            };
        };
    };
    '/w/{workspace}/jobs/run/p/{path}': {
        post: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                /**
                 * make the run invisible to the the script owner (default false)
                 */
                invisibleToOwner?: boolean;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                path: string;
                /**
                 * script args
                 */
                requestBody: ScriptArgs;
                /**
                 * when to schedule this job (leave empty for immediate run)
                 */
                scheduledFor?: string;
                /**
                 * schedule the script to execute in the number of seconds starting now
                 */
                scheduledInSecs?: number;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run_wait_result/p/{path}': {
        post: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                path: string;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * script args
                 */
                requestBody: ScriptArgs;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
        get: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                path: string;
                /**
                 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
                 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
                 *
                 */
                payload?: string;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run_wait_result/f/{path}': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                path: string;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * script args
                 */
                requestBody: ScriptArgs;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run_wait_result/fv/{version}': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * script args
                 */
                requestBody: ScriptArgs;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * flow version ID
                 */
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
        get: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
                 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
                 *
                 */
                payload?: string;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * flow version ID
                 */
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run_and_stream/f/{path}': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                path: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * flow args
                 */
                requestBody: ScriptArgs;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
        get: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                path: string;
                /**
                 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
                 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
                 *
                 */
                payload?: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/run_and_stream/fv/{version}': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * flow args
                 */
                requestBody: ScriptArgs;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * flow version ID
                 */
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
        get: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
                 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
                 *
                 */
                payload?: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * flow version ID
                 */
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/run_and_stream/p/{path}': {
        post: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                path: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * script args
                 */
                requestBody: ScriptArgs;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
        get: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                path: string;
                /**
                 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
                 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
                 *
                 */
                payload?: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/run_and_stream/h/{hash}': {
        post: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                hash: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * script args
                 */
                requestBody: ScriptArgs;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
        get: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                hash: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
                 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
                 *
                 */
                payload?: string;
                /**
                 * delay between polling for job updates in milliseconds
                 */
                pollDelayMs?: number;
                /**
                 * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
                 *
                 */
                queueLimit?: string;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/result_by_id/{flow_job_id}/{node_id}': {
        get: {
            req: {
                flowJobId: string;
                nodeId: string;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run/f/{path}': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * make the run invisible to the the flow owner (default false)
                 */
                invisibleToOwner?: boolean;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                path: string;
                /**
                 * flow args
                 */
                requestBody: ScriptArgs;
                /**
                 * when to schedule this job (leave empty for immediate run)
                 */
                scheduledFor?: string;
                /**
                 * schedule the script to execute in the number of seconds starting now
                 */
                scheduledInSecs?: number;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run/fv/{version}': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * make the run invisible to the the flow owner (default false)
                 */
                invisibleToOwner?: boolean;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * flow args
                 */
                requestBody: ScriptArgs;
                /**
                 * when to schedule this job (leave empty for immediate run)
                 */
                scheduledFor?: string;
                /**
                 * schedule the script to execute in the number of seconds starting now
                 */
                scheduledInSecs?: number;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                /**
                 * flow version ID
                 */
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run/batch_rerun_jobs': {
        post: {
            req: {
                /**
                 * list of job ids to re run and arg tranforms
                 */
                requestBody: {
                    job_ids: Array<(string)>;
                    script_options_by_path: {
                        [key: string]: {
                            input_transforms?: {
                                [key: string]: InputTransform;
                            };
                            use_latest_version?: boolean;
                        };
                    };
                    flow_options_by_path: {
                        [key: string]: {
                            input_transforms?: {
                                [key: string]: InputTransform;
                            };
                            use_latest_version?: boolean;
                        };
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * stream of created job uuids separated by \n. Lines may start with 'Error:'
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/restart/f/{id}': {
        post: {
            req: {
                id: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * make the run invisible to the the flow owner (default false)
                 */
                invisibleToOwner?: boolean;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * restart flow parameters
                 */
                requestBody: {
                    /**
                     * top-level step id to restart the flow from (or the outermost container when restarting at a nested step)
                     */
                    step_id: string;
                    /**
                     * for branchall or loop at the top level, the iteration at which the flow should restart (optional)
                     */
                    branch_or_iteration_n?: number;
                    /**
                     * specific flow version to use for restart (optional, uses current version if not specified)
                     */
                    flow_version?: number;
                    /**
                     * path of additional steps to descend into AFTER `step_id`. Each entry represents one level of nesting inside the spawned child of the previous level's container (BranchOne / sequential ForLoop iteration / Subflow). When non-empty, the actual restart point is the LAST entry's step_id.
                     */
                    nested_path?: Array<{
                        /**
                         * step id at this nesting level
                         */
                        step_id: string;
                        /**
                         * for ForLoop containers, the iteration to restart at (0-based; iterations 0..n-1 are preserved)
                         */
                        branch_or_iteration_n?: number;
                    }>;
                };
                /**
                 * when to schedule this job (leave empty for immediate run)
                 */
                scheduledFor?: string;
                /**
                 * schedule the script to execute in the number of seconds starting now
                 */
                scheduledInSecs?: number;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run/h/{hash}': {
        post: {
            req: {
                /**
                 * Override the cache time to live (in seconds). Can not be used to disable caching, only override with a new cache ttl
                 */
                cacheTtl?: string;
                hash: string;
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * make the run invisible to the the script owner (default false)
                 */
                invisibleToOwner?: boolean;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * Partially filled args
                 */
                requestBody: {
                    [key: string]: unknown;
                };
                /**
                 * when to schedule this job (leave empty for immediate run)
                 */
                scheduledFor?: string;
                /**
                 * schedule the script to execute in the number of seconds starting now
                 */
                scheduledInSecs?: number;
                /**
                 * skip the preprocessor
                 */
                skipPreprocessor?: boolean;
                /**
                 * Override the tag to use
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run/preview': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * make the run invisible to the the script owner (default false)
                 */
                invisibleToOwner?: boolean;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * preview
                 */
                requestBody: Preview;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run_inline/preview': {
        post: {
            req: {
                /**
                 * preview
                 */
                requestBody: PreviewInline;
                workspace: string;
            };
            res: {
                /**
                 * script result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run_inline/p/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * script args
                 */
                requestBody: InlineScriptArgs;
                workspace: string;
            };
            res: {
                /**
                 * script result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run_inline/h/{hash}': {
        post: {
            req: {
                hash: string;
                /**
                 * script args
                 */
                requestBody: InlineScriptArgs;
                workspace: string;
            };
            res: {
                /**
                 * script result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run_wait_result/preview': {
        post: {
            req: {
                /**
                 * preview
                 */
                requestBody: Preview;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run/code_flow/{job_id}/{entrypoint}': {
        post: {
            req: {
                entrypoint: string;
                jobId: string;
                /**
                 * preview
                 */
                requestBody: WorkflowTask;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run/dependencies': {
        post: {
            req: {
                /**
                 * raw script content
                 */
                requestBody: {
                    raw_scripts: Array<RawScriptForDependencies>;
                    entrypoint: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * dependency job result
                 */
                201: {
                    lock: string;
                };
            };
        };
    };
    '/w/{workspace}/jobs/run/dependencies_async': {
        post: {
            req: {
                /**
                 * raw script content
                 */
                requestBody: {
                    raw_scripts: Array<RawScriptForDependencies>;
                    entrypoint: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * dependency job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run/flow_dependencies_async': {
        post: {
            req: {
                /**
                 * flow value and path
                 */
                requestBody: {
                    path: string;
                    flow_value: FlowValue;
                };
                workspace: string;
            };
            res: {
                /**
                 * flow dependencies job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run/preview_flow': {
        post: {
            req: {
                /**
                 * List of headers's keys (separated with ',') whove value are added to the args
                 * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
                 *
                 */
                includeHeader?: string;
                /**
                 * make the run invisible to the the script owner (default false)
                 */
                invisibleToOwner?: boolean;
                /**
                 * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
                 */
                jobId?: string;
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * preview
                 */
                requestBody: FlowPreview;
                workspace: string;
            };
            res: {
                /**
                 * job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/run_wait_result/preview_flow': {
        post: {
            req: {
                /**
                 * memory ID for chat-enabled flows
                 */
                memoryId?: string;
                /**
                 * preview
                 */
                requestBody: FlowPreview;
                workspace: string;
            };
            res: {
                /**
                 * job result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/run/dynamic_select': {
        post: {
            req: {
                /**
                 * dynamic select request
                 */
                requestBody: DynamicInputData;
                workspace: string;
            };
            res: {
                /**
                 * dynamic select job created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/queue/list': {
        get: {
            req: {
                /**
                 * allow wildcards (*) in the filter of label, tag, worker
                 */
                allowWildcards?: boolean;
                /**
                 * get jobs from all workspaces (only valid if request come from the `admins` workspace)
                 */
                allWorkspaces?: boolean;
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * is not a scheduled job
                 */
                isNotSchedule?: boolean;
                /**
                 * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
                 */
                jobKinds?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * filter on jobs containing those result as a json subset (@> in postgres)
                 */
                result?: string;
                /**
                 * filter on running jobs
                 */
                running?: boolean;
                /**
                 * filter on jobs scheduled_for before now (hence waitinf for a worker)
                 */
                scheduledForBeforeNow?: boolean;
                /**
                 * mask to filter by schedule path
                 */
                schedulePath?: string;
                /**
                 * mask to filter exact matching path
                 */
                scriptHash?: string;
                /**
                 * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
                 */
                scriptPathExact?: string;
                /**
                 * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
                 */
                scriptPathStart?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                startedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                startedBefore?: string;
                /**
                 * filter on successful jobs
                 */
                success?: boolean;
                /**
                 * filter on suspended jobs
                 */
                suspended?: boolean;
                /**
                 * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
                 */
                tag?: string;
                /**
                 * filter by trigger kind. Supports comma-separated list (e.g. 'schedule,webhook') and negation by prefixing all values with '!' (e.g. '!schedule,!webhook')
                 */
                triggerKind?: string;
                /**
                 * filter by trigger path. Supports comma-separated list (e.g. 'f/trigger1,f/trigger2') and negation by prefixing all values with '!' (e.g. '!f/trigger1,!f/trigger2')
                 */
                triggerPath?: string;
                /**
                 * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
                 */
                worker?: string;
                workspace: string;
            };
            res: {
                /**
                 * All queued jobs
                 */
                200: Array<QueuedJob>;
            };
        };
    };
    '/w/{workspace}/jobs/queue/count': {
        get: {
            req: {
                /**
                 * get jobs from all workspaces (only valid if request come from the `admins` workspace)
                 */
                allWorkspaces?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * queue count
                 */
                200: {
                    database_length: number;
                    suspended?: number;
                };
            };
        };
    };
    '/w/{workspace}/jobs/completed/count': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * completed count
                 */
                200: {
                    database_length: number;
                };
            };
        };
    };
    '/w/{workspace}/jobs/completed/count_jobs': {
        get: {
            req: {
                allWorkspaces?: boolean;
                completedAfterSAgo?: number;
                success?: boolean;
                tags?: string;
                workspace: string;
            };
            res: {
                /**
                 * Count of completed jobs
                 */
                200: number;
            };
        };
    };
    '/w/{workspace}/jobs/list_filtered_uuids': {
        get: {
            req: {
                /**
                 * get jobs from all workspaces (only valid if request come from the `admins` workspace)
                 */
                allWorkspaces?: boolean;
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                completedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                completedBefore?: string;
                /**
                 * filter on created after (exclusive) timestamp
                 */
                createdAfter?: string;
                /**
                 * filter on jobs created after X for jobs in the queue only
                 */
                createdAfterQueue?: string;
                /**
                 * filter on created before (inclusive) timestamp
                 */
                createdBefore?: string;
                /**
                 * filter on jobs created before X for jobs in the queue only
                 */
                createdBeforeQueue?: string;
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * has null parent
                 */
                hasNullParent?: boolean;
                /**
                 * is the job a flow step
                 */
                isFlowStep?: boolean;
                /**
                 * is not a scheduled job
                 */
                isNotSchedule?: boolean;
                /**
                 * is the job skipped
                 */
                isSkipped?: boolean;
                /**
                 * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
                 */
                jobKinds?: string;
                /**
                 * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * filter on jobs containing those result as a json subset (@> in postgres)
                 */
                result?: string;
                /**
                 * filter on running jobs
                 */
                running?: boolean;
                /**
                 * filter on jobs scheduled_for before now (hence waitinf for a worker)
                 */
                scheduledForBeforeNow?: boolean;
                /**
                 * mask to filter by schedule path
                 */
                schedulePath?: string;
                /**
                 * mask to filter exact matching path
                 */
                scriptHash?: string;
                /**
                 * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
                 */
                scriptPathExact?: string;
                /**
                 * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
                 */
                scriptPathStart?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                startedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                startedBefore?: string;
                /**
                 * filter on successful jobs
                 */
                success?: boolean;
                /**
                 * filter on suspended jobs
                 */
                suspended?: boolean;
                /**
                 * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
                 */
                tag?: string;
                /**
                 * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
                 */
                worker?: string;
                workspace: string;
            };
            res: {
                /**
                 * uuids of jobs
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/jobs/queue/list_filtered_uuids': {
        get: {
            req: {
                /**
                 * allow wildcards (*) in the filter of label, tag, worker
                 */
                allowWildcards?: boolean;
                /**
                 * get jobs from all workspaces (only valid if request come from the `admins` workspace)
                 */
                allWorkspaces?: boolean;
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                concurrencyKey?: string;
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * is not a scheduled job
                 */
                isNotSchedule?: boolean;
                /**
                 * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
                 */
                jobKinds?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * filter on jobs containing those result as a json subset (@> in postgres)
                 */
                result?: string;
                /**
                 * filter on running jobs
                 */
                running?: boolean;
                /**
                 * filter on jobs scheduled_for before now (hence waitinf for a worker)
                 */
                scheduledForBeforeNow?: boolean;
                /**
                 * mask to filter by schedule path
                 */
                schedulePath?: string;
                /**
                 * mask to filter exact matching path
                 */
                scriptHash?: string;
                /**
                 * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
                 */
                scriptPathExact?: string;
                /**
                 * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
                 */
                scriptPathStart?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                startedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                startedBefore?: string;
                /**
                 * filter on successful jobs
                 */
                success?: boolean;
                /**
                 * filter on suspended jobs
                 */
                suspended?: boolean;
                /**
                 * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
                 */
                tag?: string;
                workspace: string;
            };
            res: {
                /**
                 * uuids of jobs
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/jobs/queue/cancel_selection': {
        post: {
            req: {
                allWorkspaces?: boolean;
                forceCancel?: boolean;
                /**
                 * uuids of the jobs to cancel
                 */
                requestBody: Array<(string)>;
                workspace: string;
            };
            res: {
                /**
                 * uuids of canceled jobs
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/jobs/get_otel_traces/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * list of OTEL Span objects (compatible with OpenTelemetry Span proto)
                 */
                200: Array<{
                    [key: string]: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/jobs/completed/list': {
        get: {
            req: {
                /**
                 * allow wildcards (*) in the filter of label, tag, worker
                 */
                allowWildcards?: boolean;
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * has null parent
                 */
                hasNullParent?: boolean;
                /**
                 * is the job a flow step
                 */
                isFlowStep?: boolean;
                /**
                 * is not a scheduled job
                 */
                isNotSchedule?: boolean;
                /**
                 * is the job skipped
                 */
                isSkipped?: boolean;
                /**
                 * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
                 */
                jobKinds?: string;
                /**
                 * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
                 */
                label?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * filter on jobs containing those result as a json subset (@> in postgres)
                 */
                result?: string;
                /**
                 * mask to filter by schedule path
                 */
                schedulePath?: string;
                /**
                 * mask to filter exact matching path
                 */
                scriptHash?: string;
                /**
                 * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
                 */
                scriptPathExact?: string;
                /**
                 * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
                 */
                scriptPathStart?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                startedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                startedBefore?: string;
                /**
                 * filter on successful jobs
                 */
                success?: boolean;
                /**
                 * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
                 */
                tag?: string;
                /**
                 * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
                 */
                worker?: string;
                workspace: string;
            };
            res: {
                /**
                 * All completed jobs
                 */
                200: Array<CompletedJob>;
            };
        };
    };
    '/w/{workspace}/jobs/completed/export': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * All completed jobs exported
                 */
                200: Array<ExportableCompletedJob>;
            };
        };
    };
    '/w/{workspace}/jobs/completed/import': {
        post: {
            req: {
                requestBody: Array<ExportableCompletedJob>;
                workspace: string;
            };
            res: {
                /**
                 * Successfully imported completed jobs
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/queue/export': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * All queued jobs exported
                 */
                200: Array<ExportableQueuedJob>;
            };
        };
    };
    '/w/{workspace}/jobs/queue/import': {
        post: {
            req: {
                requestBody: Array<ExportableQueuedJob>;
                workspace: string;
            };
            res: {
                /**
                 * Successfully imported queued jobs
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/delete': {
        post: {
            req: {
                requestBody: Array<(string)>;
                workspace: string;
            };
            res: {
                /**
                 * Successfully deleted jobs
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/list': {
        get: {
            req: {
                /**
                 * allow wildcards (*) in the filter of label, tag, worker
                 */
                allowWildcards?: boolean;
                /**
                 * get jobs from all workspaces (only valid if request come from the `admins` workspace)
                 */
                allWorkspaces?: boolean;
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                /**
                 * broad search across multiple fields (case-insensitive substring match on path, tag, schedule path, trigger kind, label)
                 */
                broadFilter?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                completedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                completedBefore?: string;
                /**
                 * filter on created after (exclusive) timestamp
                 */
                createdAfter?: string;
                /**
                 * filter on jobs created after X for jobs in the queue only
                 */
                createdAfterQueue?: string;
                /**
                 * filter on created before (inclusive) timestamp
                 */
                createdBefore?: string;
                /**
                 * filter on jobs created before X for jobs in the queue only
                 */
                createdBeforeQueue?: string;
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * has null parent
                 */
                hasNullParent?: boolean;
                /**
                 * is the job a flow step
                 */
                isFlowStep?: boolean;
                /**
                 * is not a scheduled job
                 */
                isNotSchedule?: boolean;
                /**
                 * is the job skipped
                 */
                isSkipped?: boolean;
                /**
                 * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
                 */
                jobKinds?: string;
                /**
                 * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
                 */
                label?: string;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * filter on jobs containing those result as a json subset (@> in postgres)
                 */
                result?: string;
                /**
                 * filter on running jobs
                 */
                running?: boolean;
                /**
                 * filter on jobs scheduled_for before now (hence waitinf for a worker)
                 */
                scheduledForBeforeNow?: boolean;
                /**
                 * mask to filter by schedule path
                 */
                schedulePath?: string;
                /**
                 * mask to filter exact matching path
                 */
                scriptHash?: string;
                /**
                 * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
                 */
                scriptPathExact?: string;
                /**
                 * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
                 */
                scriptPathStart?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                startedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                startedBefore?: string;
                /**
                 * filter on successful jobs
                 */
                success?: boolean;
                /**
                 * filter on suspended jobs
                 */
                suspended?: boolean;
                /**
                 * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
                 */
                tag?: string;
                /**
                 * filter by trigger kind. Supports comma-separated list (e.g. 'schedule,webhook') and negation by prefixing all values with '!' (e.g. '!schedule,!webhook')
                 */
                triggerKind?: string;
                /**
                 * filter by worker this job ran on. Supports comma-separated list (e.g. 'worker-1,worker-2') and negation by prefixing all values with '!' (e.g. '!worker-1,!worker-2')
                 */
                worker?: string;
                workspace: string;
            };
            res: {
                /**
                 * All jobs
                 */
                200: Array<Job>;
            };
        };
    };
    '/jobs/db_clock': {
        get: {
            res: {
                /**
                 * the timestamp of the db that can be used to compute the drift
                 */
                200: number;
            };
        };
    };
    '/jobs/completed/count_by_tag': {
        get: {
            req: {
                /**
                 * Past Time horizon in seconds (when to start the count = now - horizon) (default is 3600)
                 */
                horizonSecs?: number;
                /**
                 * Specific workspace ID to filter results (optional)
                 */
                workspaceId?: string;
            };
            res: {
                /**
                 * Job counts by tag
                 */
                200: Array<{
                    tag: string;
                    count: number;
                }>;
            };
        };
    };
    '/w/{workspace}/jobs_u/get/{id}': {
        get: {
            req: {
                /**
                 * Approval token granting read access to the job when not logged in. The token must be the one issued for this job's flow (i.e. the flow id used when generating the approval URL).
                 */
                approvalToken?: string;
                id: string;
                noCode?: boolean;
                noLogs?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * job details
                 */
                200: Job;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_root_job_id/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * get root job id
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_logs/{id}': {
        get: {
            req: {
                id: string;
                removeAnsiWarnings?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * job details
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_flow_all_logs/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * concatenated logs of all flow steps
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_completed_logs_tail/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * completed job logs tail
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_args/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * job args
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs_u/queue/get_started_at_by_ids': {
        post: {
            req: {
                /**
                 * ids
                 */
                requestBody: Array<(string)>;
                workspace: string;
            };
            res: {
                /**
                 * started at by ids
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/jobs_u/getupdate/{id}': {
        get: {
            req: {
                getProgress?: boolean;
                id: string;
                logOffset?: number;
                noLogs?: boolean;
                running?: boolean;
                streamOffset?: number;
                workspace: string;
            };
            res: {
                /**
                 * job details
                 */
                200: {
                    running?: boolean;
                    completed?: boolean;
                    new_logs?: string;
                    log_offset?: number;
                    mem_peak?: number;
                    progress?: number;
                    stream_offset?: number;
                    new_result_stream?: string;
                    flow_status?: FlowStatus;
                    code_flow_status?: WorkflowStatus;
                };
            };
        };
    };
    '/w/{workspace}/jobs_u/getupdate_sse/{id}': {
        get: {
            req: {
                fast?: boolean;
                getProgress?: boolean;
                id: string;
                logOffset?: number;
                noLogs?: boolean;
                onlyResult?: boolean;
                running?: boolean;
                streamOffset?: number;
                workspace: string;
            };
            res: {
                /**
                 * server-sent events stream of job updates
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_log_file/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * job log
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_flow_debug_info/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * flow debug info details
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs_u/completed/get/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * job details
                 */
                200: CompletedJob;
            };
        };
    };
    '/w/{workspace}/jobs_u/completed/get_result/{id}': {
        get: {
            req: {
                approver?: string;
                id: string;
                resumeId?: number;
                secret?: string;
                suspendedJob?: string;
                workspace: string;
            };
            res: {
                /**
                 * result
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs_u/completed/get_result_maybe/{id}': {
        get: {
            req: {
                getStarted?: boolean;
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * result
                 */
                200: {
                    completed: boolean;
                    result: unknown;
                    success?: boolean;
                    started?: boolean;
                };
            };
        };
    };
    '/w/{workspace}/jobs_u/completed/get_timing/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * job timing details
                 */
                200: {
                    created_at: string;
                    started_at?: string;
                    duration_ms?: number;
                };
            };
        };
    };
    '/w/{workspace}/jobs/completed/delete/{id}': {
        post: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * job details
                 */
                200: CompletedJob;
            };
        };
    };
    '/w/{workspace}/jobs_u/queue/cancel/{id}': {
        post: {
            req: {
                id: string;
                /**
                 * reason
                 */
                requestBody: {
                    reason?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * job canceled
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/queue/cancel_persistent/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * reason
                 */
                requestBody: {
                    reason?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * persistent job scaled down to zero
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/queue/force_cancel/{id}': {
        post: {
            req: {
                id: string;
                /**
                 * reason
                 */
                requestBody: {
                    reason?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * job canceled
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/queue/position/{scheduled_for}': {
        get: {
            req: {
                scheduledFor: number;
                workspace: string;
            };
            res: {
                /**
                 * queue position information
                 */
                200: {
                    /**
                     * The position in queue (1-based), null if not in queue or already running
                     */
                    position?: number;
                };
            };
        };
    };
    '/w/{workspace}/jobs/queue/scheduled_for/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * scheduled for timestamp
                 */
                200: number;
            };
        };
    };
    '/w/{workspace}/jobs/job_signature/{id}/{resume_id}': {
        get: {
            req: {
                approver?: string;
                id: string;
                resumeId: number;
                workspace: string;
            };
            res: {
                /**
                 * job signature
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/jobs/resume_urls/{id}/{resume_id}': {
        get: {
            req: {
                approver?: string;
                /**
                 * If true, generate resume URLs for the parent flow instead of the specific step. This allows pre-approvals that can be consumed by any later suspend step in the same flow.
                 */
                flowLevel?: boolean;
                id: string;
                resumeId: number;
                workspace: string;
            };
            res: {
                /**
                 * url endpoints
                 */
                200: {
                    approvalPage: string;
                    resume: string;
                    cancel: string;
                };
            };
        };
    };
    '/w/{workspace}/jobs/slack_approval/{id}': {
        get: {
            req: {
                approver?: string;
                cancelButtonText?: string;
                channelId: string;
                defaultArgsJson?: string;
                dynamicEnumsJson?: string;
                flowStepId: string;
                id: string;
                message?: string;
                resumeButtonText?: string;
                slackResourcePath: string;
                workspace: string;
            };
            res: {
                /**
                 * Interactive slack approval message sent successfully
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/teams_approval/{id}': {
        get: {
            req: {
                approver?: string;
                channelName: string;
                flowStepId: string;
                id: string;
                message?: string;
                /**
                 * Which suspend/approval round within the step this is. Defaults to 0.
                 */
                resumeId?: number;
                workspace: string;
            };
            res: {
                /**
                 * Interactive slack approval message sent successfully
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs_u/flow/resume_suspended/{job_id}': {
        post: {
            req: {
                jobId: string;
                requestBody: {
                    /**
                     * payload to send to the resumed job
                     */
                    payload?: unknown;
                    /**
                     * approval token for unauthenticated access
                     */
                    approval_token?: string;
                    /**
                     * whether to approve (true) or cancel (false) the job
                     */
                    approved?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * job resumed
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/flow/approval_info/{job_id}': {
        get: {
            req: {
                jobId: string;
                /**
                 * approval token for unauthenticated access
                 */
                token?: string;
                workspace: string;
            };
            res: {
                /**
                 * approval info
                 */
                200: {
                    flow_id: string;
                    /**
                     * form schema for the approval step
                     */
                    form_schema?: unknown;
                    /**
                     * description of the approval step
                     */
                    description?: unknown;
                    approval_conditions?: {
                        user_auth_required: boolean;
                        user_groups_required: Array<(string)>;
                        self_approval_disabled: boolean;
                    };
                    /**
                     * whether the current user/token holder can approve
                     */
                    can_approve: boolean;
                    /**
                     * whether user authentication is required to approve
                     */
                    user_auth_required: boolean;
                    /**
                     * whether to hide the cancel button in the UI
                     */
                    hide_cancel?: boolean;
                    approvers: Array<{
                        resume_id: number;
                        approver: string;
                    }>;
                };
            };
        };
    };
    '/w/{workspace}/jobs_u/resume/{id}/{resume_id}/{signature}': {
        get: {
            req: {
                approver?: string;
                id: string;
                /**
                 * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
                 * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
                 *
                 */
                payload?: string;
                resumeId: number;
                signature: string;
                workspace: string;
            };
            res: {
                /**
                 * job resumed
                 */
                201: string;
            };
        };
        post: {
            req: {
                approver?: string;
                id: string;
                requestBody: {
                    [key: string]: unknown;
                };
                resumeId: number;
                signature: string;
                workspace: string;
            };
            res: {
                /**
                 * job resumed
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs/flow/user_states/{id}/{key}': {
        post: {
            req: {
                id: string;
                key: string;
                /**
                 * new value
                 */
                requestBody: unknown;
                workspace: string;
            };
            res: {
                /**
                 * flow user state updated
                 */
                200: string;
            };
        };
        get: {
            req: {
                id: string;
                key: string;
                workspace: string;
            };
            res: {
                /**
                 * flow user state updated
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/jobs/flow/resume/{id}': {
        post: {
            req: {
                id: string;
                requestBody: {
                    [key: string]: unknown;
                };
                workspace: string;
            };
            res: {
                /**
                 * job resumed
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/cancel/{id}/{resume_id}/{signature}': {
        get: {
            req: {
                approver?: string;
                id: string;
                resumeId: number;
                signature: string;
                workspace: string;
            };
            res: {
                /**
                 * job canceled
                 */
                201: string;
            };
        };
        post: {
            req: {
                approver?: string;
                id: string;
                requestBody: {
                    [key: string]: unknown;
                };
                resumeId: number;
                signature: string;
                workspace: string;
            };
            res: {
                /**
                 * job canceled
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/jobs_u/get_flow/{id}/{resume_id}/{signature}': {
        get: {
            req: {
                approver?: string;
                id: string;
                resumeId: number;
                signature: string;
                workspace: string;
            };
            res: {
                /**
                 * parent flow details
                 */
                200: {
                    job: Job;
                    approvers: Array<{
                        resume_id: number;
                        approver: string;
                    }>;
                };
            };
        };
    };
    '/w/{workspace}/concurrency_groups/list_jobs': {
        get: {
            req: {
                /**
                 * allow wildcards (*) in the filter of label, tag, worker
                 */
                allowWildcards?: boolean;
                /**
                 * get jobs from all workspaces (only valid if request come from the `admins` workspace)
                 */
                allWorkspaces?: boolean;
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                completedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                completedBefore?: string;
                concurrencyKey?: string;
                /**
                 * filter on jobs created after X for jobs in the queue only
                 */
                createdAfterQueue?: string;
                /**
                 * filter on jobs created before X for jobs in the queue only
                 */
                createdBeforeQueue?: string;
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * has null parent
                 */
                hasNullParent?: boolean;
                /**
                 * is the job a flow step
                 */
                isFlowStep?: boolean;
                /**
                 * is not a scheduled job
                 */
                isNotSchedule?: boolean;
                /**
                 * is the job skipped
                 */
                isSkipped?: boolean;
                /**
                 * filter by job kind. Supports comma-separated list of values ('preview', 'script', 'dependencies', 'flow') and negation by prefixing all values with '!' (e.g. '!preview,!dependencies')
                 */
                jobKinds?: string;
                /**
                 * filter by exact matching job label. Supports comma-separated list (e.g. 'deploy,release') and negation by prefixing all values with '!' (e.g. '!deploy,!release')
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * The parent job that is at the origin and responsible for the execution of this script if any
                 */
                parentJob?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * filter on jobs containing those result as a json subset (@> in postgres)
                 */
                result?: string;
                rowLimit?: number;
                /**
                 * filter on running jobs
                 */
                running?: boolean;
                /**
                 * filter on jobs scheduled_for before now (hence waitinf for a worker)
                 */
                scheduledForBeforeNow?: boolean;
                /**
                 * mask to filter by schedule path
                 */
                schedulePath?: string;
                /**
                 * mask to filter exact matching path
                 */
                scriptHash?: string;
                /**
                 * filter by exact matching script path. Supports comma-separated list (e.g. 'f/script1,f/script2') and negation by prefixing all values with '!' (e.g. '!f/script1,!f/script2')
                 */
                scriptPathExact?: string;
                /**
                 * filter by script path prefix. Supports comma-separated list (e.g. 'f/folder1,f/folder2') and negation by prefixing all values with '!' (e.g. '!f/folder1,!f/folder2')
                 */
                scriptPathStart?: string;
                /**
                 * filter on started after (exclusive) timestamp
                 */
                startedAfter?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                startedBefore?: string;
                /**
                 * filter on successful jobs
                 */
                success?: boolean;
                /**
                 * filter by tag/worker group. Supports comma-separated list (e.g. 'gpu,highmem') and negation by prefixing all values with '!' (e.g. '!gpu,!highmem')
                 */
                tag?: string;
                /**
                 * filter by trigger kind. Supports comma-separated list (e.g. 'schedule,webhook') and negation by prefixing all values with '!' (e.g. '!schedule,!webhook')
                 */
                triggerKind?: string;
                workspace: string;
            };
            res: {
                /**
                 * time
                 */
                200: ExtendedJobs;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/create': {
        post: {
            req: {
                /**
                 * BPMN flow to create
                 */
                requestBody: NewBpmnFlow;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow created
                 */
                201: BpmnDeployResult;
                /**
                 * The document could not be parsed, or failed deploy-time
                 * validation. `issues` names the offending element(s) so an editor
                 * can anchor the failure on the canvas.
                 *
                 */
                400: BpmnValidationProblem;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * BPMN flow to update
                 */
                requestBody: NewBpmnFlow;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow updated
                 */
                200: BpmnDeployResult;
                /**
                 * The document could not be parsed, or failed deploy-time
                 * validation. `issues` names the offending element(s) so an editor
                 * can anchor the failure on the canvas.
                 *
                 */
                400: BpmnValidationProblem;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow details
                 */
                200: BpmnFlow;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/get/draft/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow details with draft
                 */
                200: BpmnFlowWithDraft;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow exists
                 */
                200: boolean;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/list': {
        get: {
            req: {
                /**
                 * Filter by the user who last edited the flow
                 */
                editedBy?: string;
                includeDraftOnly?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * mask to filter exact matching path
                 */
                pathExact?: string;
                /**
                 * mask to filter matching starting path
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                showArchived?: boolean;
                /**
                 * (default false)
                 * show only the starred items
                 *
                 */
                starredOnly?: boolean;
                /**
                 * Return NULL for description to reduce payload size
                 */
                withoutDescription?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * All BPMN flows
                 */
                200: Array<ListableBpmnFlow>;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/list_search': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow search list
                 */
                200: Array<{
                    path: string;
                    /**
                     * A projection of the flow's BPMN document — element
                     * id/name plus the orvanta:scriptPath / scriptHash /
                     * decisionRef extension values — never the raw
                     * bpmn_xml, which is dominated by namespace
                     * declarations and bpmndi: diagram-interchange
                     * coordinates that would swamp client-side fuzzy
                     * search scoring.
                     *
                     */
                    value: {
                        process: SearchBpmnNode;
                        elements: Array<SearchBpmnNode>;
                    };
                }>;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/list_paths': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of BPMN flow paths
                 */
                200: Array<(string)>;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/history/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow history
                 */
                200: Array<BpmnFlowVersion>;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/get/v/{version}/p/{path}': {
        get: {
            req: {
                path: string;
                version: number;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow version details
                 */
                200: BpmnFlow;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/archive/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * archive BPMN flow
                 */
                requestBody: {
                    archived?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow archived
                 */
                200: string;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_flows/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN flow deleted
                 */
                200: string;
                /**
                 * the flow still has running process instances pinned to one of its versions; archive it instead, or wait for them to finish
                 */
                400: unknown;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/quick_starts/polyglot_bpmn': {
        post: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * The process is deployed (or already was -- see `already_seeded`). Idempotent: safe to call again after a partial failure, which creates only whatever is still missing rather than erroring on what already exists.
                 */
                200: PolyglotBpmnSeedResult;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. Checked before creating anything, so a Teams-tier
                 * caller gets this with zero side effects -- never five orphaned
                 * scripts for a process it isn't entitled to deploy.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn_delegates/list': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * The bindings visible to the caller. RLS-filtered: a binding in
                 * another user's namespace is absent, not forbidden.
                 *
                 */
                200: Array<ListedBpmnDelegateBinding>;
            };
        };
    };
    '/w/{workspace}/bpmn_delegates/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * the binding
                 */
                200: BpmnDelegateBinding;
                /**
                 * no such binding, or none visible to the caller
                 */
                404: unknown;
            };
        };
    };
    '/w/{workspace}/bpmn_delegates/create': {
        post: {
            req: {
                requestBody: NewBpmnDelegateBinding;
                workspace: string;
            };
            res: {
                /**
                 * created; the body is the binding's path
                 */
                201: string;
                /**
                 * The row's shape is invalid -- a `script` binding with no
                 * `script_path`, a `noop`/`fail` with no `reason`, a blank key, or a
                 * key already bound in this workspace.
                 *
                 */
                400: unknown;
                /**
                 * You are not an owner of the binding's path, or not an owner of the
                 * **target script**. You may only bind to a script you could have
                 * written yourself -- a binding must never confer access its author
                 * does not have.
                 *
                 */
                401: unknown;
            };
        };
    };
    '/w/{workspace}/bpmn_delegates/update/{path}': {
        post: {
            req: {
                path: string;
                requestBody: NewBpmnDelegateBinding;
                workspace: string;
            };
            res: {
                /**
                 * updated; the body is the binding's path
                 */
                200: string;
                /**
                 * An invalid shape, or an attempt to change `delegate_key`. The key is
                 * an external identifier that deployed models reference by name;
                 * repointing it in place would rebind all of them without touching a
                 * single model. Delete and re-create instead. A `BEFORE UPDATE`
                 * database trigger enforces the same rule for non-admins.
                 *
                 */
                400: unknown;
            };
        };
    };
    '/w/{workspace}/bpmn_delegates/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * deleted
                 */
                200: string;
                /**
                 * no such binding, or none visible to the caller
                 */
                404: unknown;
            };
        };
    };
    '/w/{workspace}/bpmn_delegates/unbound': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * One entry per distinct `(key_kind, key)` with no binding row, carrying every element that references it.
                 */
                200: Array<UnboundDelegateChecklistEntry>;
            };
        };
    };
    '/w/{workspace}/bpmn_delegates/import': {
        post: {
            req: {
                requestBody: Array<NewBpmnDelegateBinding>;
                workspace: string;
            };
            res: {
                /**
                 * every binding path created vs. updated in place
                 */
                200: ImportDelegateBindingsResult;
                /**
                 * an invalid row shape, same as `create`
                 */
                400: unknown;
                /**
                 * You are not an admin, or (per row) not an owner of the binding's path or the target script.
                 */
                401: unknown;
            };
        };
    };
    '/w/{workspace}/bpmn/run/p/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * initial process variables
                 */
                requestBody: StartBpmnInstance;
                workspace: string;
            };
            res: {
                /**
                 * BPMN process instance started, returns the instance id
                 */
                201: string;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/run/preview': {
        post: {
            req: {
                /**
                 * inline BPMN XML plus initial process variables
                 */
                requestBody: PreviewBpmnInstance;
                workspace: string;
            };
            res: {
                /**
                 * BPMN process instance started, returns the instance id
                 */
                201: string;
                /**
                 * The submitted document could not be parsed, or failed
                 * deploy-time validation. `issues` names the offending element(s)
                 * so an editor can anchor the failure on the canvas.
                 *
                 */
                400: BpmnValidationProblem;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/list': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * BPMN process instances
                 */
                200: Array<BpmnInstanceSummary>;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/user-tasks/list': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * pending user tasks, oldest park first
                 */
                200: Array<PendingUserTask>;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. Same reasoning as the instance list above: the
                 * capability is built, so this is `require_entitled` failing.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/{id}/user-tasks/{user_task_id}/complete': {
        post: {
            req: {
                /**
                 * the process instance id
                 */
                id: string;
                requestBody: {
                    [key: string]: unknown;
                };
                /**
                 * the `<userTask>` element id
                 */
                userTaskId: string;
                workspace: string;
            };
            res: {
                /**
                 * the task was completed and the instance unparked
                 */
                200: string;
                /**
                 * The task declares an assignee, candidate user or candidate group
                 * that does not include the caller.
                 *
                 */
                401: string;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/get/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN process instance detail (lifecycle, tokens, activities, variables, incidents)
                 */
                200: BpmnInstanceDetail;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/get/{id}/status': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN process instance status projection
                 */
                200: ProcessInstanceStatus;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/cancel/{id}': {
        post: {
            req: {
                id: string;
                /**
                 * cancel reason
                 */
                requestBody: CancelBpmnInstance;
                workspace: string;
            };
            res: {
                /**
                 * BPMN process instance canceled
                 */
                200: string;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/{id}/incidents': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * BPMN process instance incidents
                 */
                200: Array<BpmnIncident>;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/{id}/incidents/{job_id}/retry': {
        post: {
            req: {
                id: string;
                /**
                 * the failed child job id identifying the incident to retry (Incident.job)
                 */
                jobId: string;
                workspace: string;
            };
            res: {
                /**
                 * retry requested
                 */
                200: string;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/version_rollup': {
        get: {
            req: {
                /**
                 * Set false to return counts only and skip every per-version migratability check. `migratable_to_latest` then comes back null with `check_error` saying so, never false.
                 */
                check?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * pinned-version rollup for the workspace
                 */
                200: BpmnVersionRollup;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/version_rollup/p/{path}': {
        get: {
            req: {
                check?: boolean;
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * pinned-version rollup for one flow
                 */
                200: BpmnVersionRollup;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/migration/check/p/{path}': {
        get: {
            req: {
                fromVersion: number;
                path: string;
                toVersion: number;
                workspace: string;
            };
            res: {
                /**
                 * migration eligibility for the version pair
                 */
                200: BpmnMigrationCheck;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/{id}/migration/check': {
        get: {
            req: {
                id: string;
                targetVersion: number;
                workspace: string;
            };
            res: {
                /**
                 * migration eligibility for this instance
                 */
                200: BpmnMigrationCheck;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/migration/plan/p/{path}': {
        post: {
            req: {
                path: string;
                requestBody: {
                    from_version: number;
                    to_version: number;
                    mapping?: BpmnMigrationMapping;
                };
                workspace: string;
            };
            res: {
                /**
                 * the mapping verdict, and the resolved plan if it holds
                 */
                200: BpmnMigrationPlanCheck;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/{id}/migration/plan': {
        post: {
            req: {
                id: string;
                requestBody: {
                    target_version: number;
                    mapping?: BpmnMigrationMapping;
                };
                workspace: string;
            };
            res: {
                /**
                 * the mapping verdict, and the resolved plan if it holds
                 */
                200: BpmnMigrationPlanCheck;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/{id}/migrate': {
        post: {
            req: {
                id: string;
                requestBody: {
                    target_version: number;
                    /**
                     * validate and report, write nothing
                     */
                    dry_run?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * what the migration did
                 */
                200: BpmnMigrationResult;
                /**
                 * The pair failed the contract (body carries `blockers`), the instance cannot resolve its model through the pin, or another migration moved the pin concurrently.
                 */
                400: BpmnMigrationRefusal;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/bpmn/instances/migrate': {
        post: {
            req: {
                requestBody: {
                    from_version: number;
                    target_version: number;
                    dry_run?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * what the migration did
                 */
                200: BpmnMigrationResult;
                /**
                 * the pair failed the contract (body carries `blockers`)
                 */
                400: BpmnMigrationRefusal;
                /**
                 * The workspace's licence tier is below Enterprise, `BpmnFlow`'s
                 * `min_tier`. The feature is built (`Feature::BpmnFlow.built`
                 * has been `true` since #483) so this is `require_entitled`
                 * failing, never `require_built` -- a `404` from this operation
                 * means something else (missing path, etc.), never "not
                 * entitled" (#722, #729).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/create': {
        post: {
            req: {
                /**
                 * DMN decision to create
                 */
                requestBody: NewDmnDecision;
                workspace: string;
            };
            res: {
                /**
                 * DMN decision created
                 */
                201: string;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * DMN decision to update
                 */
                requestBody: NewDmnDecision;
                workspace: string;
            };
            res: {
                /**
                 * DMN decision updated
                 */
                200: string;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * DMN decision details
                 */
                200: DmnDecision;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/get/draft/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * DMN decision details with draft
                 */
                200: DmnDecisionWithDraft;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * DMN decision exists
                 */
                200: boolean;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/list': {
        get: {
            req: {
                /**
                 * Filter by the user who last edited the decision
                 */
                editedBy?: string;
                includeDraftOnly?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * mask to filter exact matching path
                 */
                pathExact?: string;
                /**
                 * mask to filter matching starting path
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                showArchived?: boolean;
                /**
                 * Return NULL for description to reduce payload size
                 */
                withoutDescription?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * All DMN decisions
                 */
                200: Array<ListableDmnDecision>;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/history/p/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * DMN decision history
                 */
                200: Array<DmnDecisionVersion>;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/archive/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * archive DMN decision
                 */
                requestBody: {
                    archived?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * DMN decision archived
                 */
                200: string;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * DMN decision deleted
                 */
                200: string;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/evaluate': {
        post: {
            req: {
                /**
                 * decision reference (saved path or inline XML) plus input values
                 */
                requestBody: EvaluateRequest;
                workspace: string;
            };
            res: {
                /**
                 * evaluation result
                 */
                200: EvaluateResponse;
                /**
                 * The workspace's licence tier is below Enterprise,
                 * `DecisionModels`'s `min_tier`. Reachable only once
                 * `Feature::DecisionModels.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead,
                 * since `require_built` runs before `require_entitled` (#722).
                 * Documented now (#729) so the contract doesn't need a second
                 * spec change when it ships.
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/dmn_decisions/evaluate_service': {
        post: {
            req: {
                /**
                 * document reference (saved path or inline XML), the decision service id, and input values
                 */
                requestBody: EvaluateServiceRequest;
                workspace: string;
            };
            res: {
                /**
                 * decision-service evaluation result
                 */
                200: EvaluateServiceResponse;
                /**
                 * The workspace's licence tier is below Enterprise, `DecisionServices`'s `min_tier`.
                 * Reachable only once `Feature::DecisionServices.built` flips to `true` (end of the
                 * #721 programme) -- until then this operation 404s instead, since `require_built`
                 * runs before `require_entitled` (#722).
                 *
                 */
                402: string;
            };
        };
    };
    '/w/{workspace}/flow_conversations/list': {
        get: {
            req: {
                /**
                 * filter conversations by flow path
                 */
                flowPath?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * flow conversations list
                 */
                200: Array<FlowConversation>;
            };
        };
    };
    '/w/{workspace}/flow_conversations/delete/{conversation_id}': {
        delete: {
            req: {
                /**
                 * conversation id
                 */
                conversationId: string;
                workspace: string;
            };
            res: {
                /**
                 * flow conversation deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/flow_conversations/{conversation_id}/messages': {
        get: {
            req: {
                /**
                 * Message sequence cursor to fetch only the messages after that cursor
                 */
                afterSeq?: number;
                /**
                 * conversation id
                 */
                conversationId: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * conversation messages
                 */
                200: Array<FlowConversationMessage>;
            };
        };
    };
    '/w/{workspace}/path_autocomplete/list_paths': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * deduplicated path list, sorted lexicographically
                 */
                200: {
                    paths: Array<(string)>;
                };
            };
        };
    };
    '/w/{workspace}/raw_apps/list': {
        get: {
            req: {
                /**
                 * filter by exact matching user creator. Supports comma-separated list (e.g. 'alice,bob') and negation by prefixing all values with '!' (e.g. '!alice,!bob')
                 */
                createdBy?: string;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * order by desc order (default true)
                 */
                orderDesc?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * mask to filter exact matching path
                 */
                pathExact?: string;
                /**
                 * mask to filter matching starting path
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * (default false)
                 * show only the starred items
                 *
                 */
                starredOnly?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * All raw apps
                 */
                200: Array<ListableRawApp>;
            };
        };
    };
    '/w/{workspace}/trigger/{trigger_kind}/resume_suspended_trigger_jobs/{trigger_path}': {
        post: {
            req: {
                /**
                 * Optional list of job IDs to reassign
                 */
                requestBody?: {
                    /**
                     * Optional list of specific job UUIDs to reassign. If not provided, all suspended jobs for the trigger will be reassigned.
                     */
                    job_ids?: Array<(string)>;
                };
                /**
                 * The kind of trigger
                 */
                triggerKind: JobTriggerKind;
                /**
                 * The path of the trigger (can contain forward slashes)
                 */
                triggerPath: string;
                workspace: string;
            };
            res: {
                /**
                 * confirmation message
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/trigger/{trigger_kind}/cancel_suspended_trigger_jobs/{trigger_path}': {
        post: {
            req: {
                /**
                 * Optional list of job IDs to cancel
                 */
                requestBody?: {
                    /**
                     * Optional list of specific job UUIDs to cancel. If not provided, all suspended jobs for the trigger will be canceled.
                     */
                    job_ids?: Array<(string)>;
                };
                /**
                 * The kind of trigger
                 */
                triggerKind: JobTriggerKind;
                /**
                 * The path of the trigger (can contain forward slashes)
                 */
                triggerPath: string;
                workspace: string;
            };
            res: {
                /**
                 * confirmation message
                 */
                200: string;
            };
        };
    };
    '/schedules/preview': {
        post: {
            req: {
                /**
                 * schedule
                 */
                requestBody: {
                    schedule: string;
                    timezone: string;
                    cron_version?: string;
                    /**
                     * Defaults to true (6-field cron, matching createSchedule). Pass false to validate under the same rule the BPMN timer-start deploy-time reconciler uses (seconds optional, so 5- and 6-field expressions both validate).
                     */
                    seconds_required?: boolean;
                };
            };
            res: {
                /**
                 * List of 5 estimated upcoming execution events (in UTC)
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/schedules/create': {
        post: {
            req: {
                /**
                 * new schedule
                 */
                requestBody: NewSchedule;
                workspace: string;
            };
            res: {
                /**
                 * schedule created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/schedules/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated schedule
                 */
                requestBody: EditSchedule;
                workspace: string;
            };
            res: {
                /**
                 * schedule updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/schedules/setenabled/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated schedule enable
                 */
                requestBody: {
                    enabled: boolean;
                    /**
                     * Bypass the parent-state conflict warning when enabling a schedule in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * schedule enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/schedules/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * schedule deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/schedules/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * schedule deleted
                 */
                200: Schedule;
            };
        };
    };
    '/w/{workspace}/schedules/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * schedule exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/schedules/list': {
        get: {
            req: {
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                /**
                 * broad search across multiple fields (case-insensitive substring match)
                 */
                broadFilter?: string;
                /**
                 * pattern match filter for description field (case-insensitive)
                 */
                description?: string;
                /**
                 * filter schedules by whether they target a flow
                 */
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path (script path)
                 */
                path?: string;
                /**
                 * filter schedules by path prefix
                 */
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                /**
                 * exact match on the schedule's path
                 */
                schedulePath?: string;
                /**
                 * pattern match filter for summary field (case-insensitive)
                 */
                summary?: string;
                workspace: string;
            };
            res: {
                /**
                 * schedule list
                 */
                200: Array<Schedule>;
            };
        };
    };
    '/w/{workspace}/schedules/list_with_jobs': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * schedule list
                 */
                200: Array<ScheduleWJobs>;
            };
        };
    };
    '/w/{workspace}/schedules/setdefaulthandler': {
        post: {
            req: {
                /**
                 * Handler description
                 */
                requestBody: {
                    handler_type: 'error' | 'recovery' | 'success';
                    override_existing: boolean;
                    path?: string;
                    extra_args?: {
                        [key: string]: unknown;
                    };
                    number_of_occurence?: number;
                    number_of_occurence_exact?: boolean;
                    workspace_handler_muted?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * default error handler set
                 */
                201: unknown;
            };
        };
    };
    '/w/{workspace}/openapi/generate': {
        post: {
            req: {
                /**
                 * openapi spec info and url
                 */
                requestBody?: GenerateOpenapiSpec;
                workspace: string;
            };
            res: {
                /**
                 * openapi spec
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/openapi/download': {
        post: {
            req: {
                /**
                 * openapi spec info and url
                 */
                requestBody?: GenerateOpenapiSpec;
                workspace: string;
            };
            res: {
                /**
                 * Downloaded OpenAPI spec
                 */
                200: (Blob | File);
            };
        };
    };
    '/w/{workspace}/http_triggers/create_many': {
        post: {
            req: {
                /**
                 * new http trigger
                 */
                requestBody: Array<NewHttpTrigger>;
                workspace: string;
            };
            res: {
                /**
                 * http trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/http_triggers/create': {
        post: {
            req: {
                /**
                 * new http trigger
                 */
                requestBody: NewHttpTrigger;
                workspace: string;
            };
            res: {
                /**
                 * http trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/http_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditHttpTrigger;
                workspace: string;
            };
            res: {
                /**
                 * http trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/http_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * http trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/http_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * http trigger deleted
                 */
                200: HttpTrigger;
            };
        };
    };
    '/w/{workspace}/http_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * http trigger list
                 */
                200: Array<HttpTrigger>;
            };
        };
    };
    '/w/{workspace}/http_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * http trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/http_triggers/route_exists': {
        post: {
            req: {
                /**
                 * route exists request
                 */
                requestBody: {
                    route_path: string;
                    http_method: HttpMethod;
                    trigger_path?: string;
                    workspaced_route?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * route exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/http_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * http trigger enable/disable
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/create': {
        post: {
            req: {
                /**
                 * new websocket trigger
                 */
                requestBody: NewWebsocketTrigger;
                workspace: string;
            };
            res: {
                /**
                 * websocket trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditWebsocketTrigger;
                workspace: string;
            };
            res: {
                /**
                 * websocket trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * websocket trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * websocket trigger deleted
                 */
                200: WebsocketTrigger;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * websocket trigger list
                 */
                200: Array<WebsocketTrigger>;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * websocket trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated websocket trigger enable
                 */
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * websocket trigger enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/websocket_triggers/test': {
        post: {
            req: {
                /**
                 * test websocket connection
                 */
                requestBody: {
                    url: string;
                    url_runnable_args?: ScriptArgs;
                    can_return_message: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * successfuly connected to websocket
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/create': {
        post: {
            req: {
                /**
                 * new kafka trigger
                 */
                requestBody: NewKafkaTrigger;
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditKafkaTrigger;
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger deleted
                 */
                200: KafkaTrigger;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger list
                 */
                200: Array<KafkaTrigger>;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated kafka trigger enable
                 */
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/test': {
        post: {
            req: {
                /**
                 * test kafka connection
                 */
                requestBody: {
                    connection: {
                        [key: string]: unknown;
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * successfuly connected to kafka brokers
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/reset_offsets/{path}': {
        post: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * kafka trigger offsets reset successfully
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/kafka_triggers/commit_offsets/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * offsets to commit
                 */
                requestBody: {
                    topic: string;
                    partition: number;
                    offset: number;
                };
                workspace: string;
            };
            res: {
                /**
                 * kafka offsets committed successfully
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/nats_triggers/create': {
        post: {
            req: {
                /**
                 * new nats trigger
                 */
                requestBody: NewNatsTrigger;
                workspace: string;
            };
            res: {
                /**
                 * nats trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/nats_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditNatsTrigger;
                workspace: string;
            };
            res: {
                /**
                 * nats trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/nats_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * nats trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/nats_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * nats trigger deleted
                 */
                200: NatsTrigger;
            };
        };
    };
    '/w/{workspace}/nats_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * nats trigger list
                 */
                200: Array<NatsTrigger>;
            };
        };
    };
    '/w/{workspace}/nats_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * nats trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/nats_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated nats trigger enable
                 */
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * nats trigger enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/nats_triggers/test': {
        post: {
            req: {
                /**
                 * test nats connection
                 */
                requestBody: {
                    connection: {
                        [key: string]: unknown;
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * successfuly connected to NATS servers
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/create': {
        post: {
            req: {
                /**
                 * new sqs trigger
                 */
                requestBody: NewSqsTrigger;
                workspace: string;
            };
            res: {
                /**
                 * sqs trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditSqsTrigger;
                workspace: string;
            };
            res: {
                /**
                 * sqs trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * sqs trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * sqs trigger deleted
                 */
                200: SqsTrigger;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * sqs trigger list
                 */
                200: Array<SqsTrigger>;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * sqs trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated sqs trigger enable
                 */
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * sqs trigger enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/sqs_triggers/test': {
        post: {
            req: {
                /**
                 * test sqs connection
                 */
                requestBody: {
                    connection: {
                        [key: string]: unknown;
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * successfuly connected to sqs
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/list': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * native trigger services list
                 */
                200: Array<WorkspaceIntegrations>;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/{service_name}/exists': {
        get: {
            req: {
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * integration exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/{service_name}/create': {
        post: {
            req: {
                /**
                 * new native trigger service
                 */
                requestBody: WorkspaceOAuthConfig;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger service created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/{service_name}/generate_connect_url': {
        post: {
            req: {
                /**
                 * redirect_uri
                 */
                requestBody: RedirectUri;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger service connect url
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/{service_name}/instance_sharing_available': {
        get: {
            req: {
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * whether instance sharing is available
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/{service_name}/generate_instance_connect_url': {
        post: {
            req: {
                /**
                 * redirect_uri
                 */
                requestBody: RedirectUri;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * authorization URL using instance credentials
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/{service_name}/delete': {
        delete: {
            req: {
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger service deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/integrations/{service_name}/callback': {
        post: {
            req: {
                /**
                 * OAuth callback data
                 */
                requestBody: {
                    code: string;
                    state: string;
                    redirect_uri: string;
                    resource_path?: string;
                };
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger service oauth completed
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/{service_name}/create': {
        post: {
            req: {
                /**
                 * new native trigger configuration
                 */
                requestBody: NativeTriggerData;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger created
                 */
                201: CreateTriggerResponse;
            };
        };
    };
    '/w/{workspace}/native_triggers/{service_name}/update/{external_id}': {
        post: {
            req: {
                /**
                 * The external ID of the trigger from the external service
                 */
                externalId: string;
                /**
                 * updated native trigger configuration
                 */
                requestBody: NativeTriggerData;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/{service_name}/get/{external_id}': {
        get: {
            req: {
                /**
                 * The external ID of the trigger from the external service
                 */
                externalId: string;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger with external configuration
                 */
                200: NativeTriggerWithExternal;
            };
        };
    };
    '/w/{workspace}/native_triggers/{service_name}/delete/{external_id}': {
        delete: {
            req: {
                /**
                 * The external ID of the trigger from the external service
                 */
                externalId: string;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/native_triggers/{service_name}/list': {
        get: {
            req: {
                /**
                 * filter by is_flow
                 */
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by script path
                 */
                path?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * native triggers list
                 */
                200: Array<NativeTrigger>;
            };
        };
    };
    '/w/{workspace}/native_triggers/{service_name}/exists/{external_id}': {
        get: {
            req: {
                /**
                 * The external ID of the trigger from the external service
                 */
                externalId: string;
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * whether the native trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/native_triggers/{service_name}/sync': {
        post: {
            req: {
                serviceName: NativeServiceName;
                workspace: string;
            };
            res: {
                /**
                 * sync completed successfully
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/native_triggers/nextcloud/events': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of available NextCloud events
                 */
                200: Array<NextCloudEventType>;
            };
        };
    };
    '/w/{workspace}/native_triggers/google/calendars': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of Google Calendars
                 */
                200: Array<GoogleCalendarEntry>;
            };
        };
    };
    '/w/{workspace}/native_triggers/google/drive/files': {
        get: {
            req: {
                /**
                 * token for next page of results
                 */
                pageToken?: string;
                /**
                 * folder ID to list children of
                 */
                parentId?: string;
                /**
                 * search query to filter files by name
                 */
                q?: string;
                /**
                 * if true, list files shared with the user
                 */
                sharedWithMe?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * list of Google Drive files
                 */
                200: GoogleDriveFilesResponse;
            };
        };
    };
    '/w/{workspace}/native_triggers/google/drive/shared_drives': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of shared drives
                 */
                200: Array<SharedDriveEntry>;
            };
        };
    };
    '/w/{workspace}/native_triggers/github/repos': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of GitHub repositories
                 */
                200: Array<GithubRepoEntry>;
            };
        };
    };
    '/native_triggers/{service_name}/w/{workspace_id}/webhook/{internal_id}': {
        post: {
            req: {
                /**
                 * The internal database ID of the trigger
                 */
                internalId: number;
                /**
                 * webhook payload from external service
                 */
                requestBody?: {
                    [key: string]: unknown;
                };
                serviceName: NativeServiceName;
                workspaceId: string;
            };
            res: {
                /**
                 * webhook received successfully
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/create': {
        post: {
            req: {
                /**
                 * new mqtt trigger
                 */
                requestBody: NewMqttTrigger;
                workspace: string;
            };
            res: {
                /**
                 * mqtt trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditMqttTrigger;
                workspace: string;
            };
            res: {
                /**
                 * mqtt trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * mqtt trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * mqtt trigger deleted
                 */
                200: MqttTrigger;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * mqtt trigger list
                 */
                200: Array<MqttTrigger>;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * mqtt trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated mqtt trigger enable
                 */
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * mqtt trigger enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/mqtt_triggers/test': {
        post: {
            req: {
                /**
                 * test mqtt connection
                 */
                requestBody: {
                    connection: {
                        [key: string]: unknown;
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * successfully connected to mqtt
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/create': {
        post: {
            req: {
                /**
                 * new gcp trigger
                 */
                requestBody: GcpTriggerData;
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: GcpTriggerData;
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger deleted
                 */
                200: GcpTrigger;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger list
                 */
                200: Array<GcpTrigger>;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated gcp trigger enable
                 */
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/test': {
        post: {
            req: {
                /**
                 * test gcp connection
                 */
                requestBody: {
                    connection: {
                        [key: string]: unknown;
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * try to connect to a gcp broker
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/subscriptions/delete/{path}': {
        delete: {
            req: {
                path: string;
                /**
                 * args to delete subscription from google cloud
                 */
                requestBody: DeleteGcpSubscription;
                workspace: string;
            };
            res: {
                /**
                 * gcp trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/topics/list/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * get all google topics
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/gcp_triggers/subscriptions/list/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * args to get subscription's topic from google cloud
                 */
                requestBody: GetAllTopicSubscription;
                workspace: string;
            };
            res: {
                /**
                 * get all google topic subscriptions name
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/azure_triggers/create': {
        post: {
            req: {
                requestBody: AzureTriggerData;
                workspace: string;
            };
            res: {
                /**
                 * azure trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/azure_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                requestBody: AzureTriggerData;
                workspace: string;
            };
            res: {
                /**
                 * azure trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/azure_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * azure trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/azure_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * azure trigger
                 */
                200: AzureTrigger;
            };
        };
    };
    '/w/{workspace}/azure_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by exact path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * azure trigger list
                 */
                200: Array<AzureTrigger>;
            };
        };
    };
    '/w/{workspace}/azure_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * true/false
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/azure_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * trigger mode updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/azure_triggers/test': {
        post: {
            req: {
                requestBody: TestAzureConnection;
                workspace: string;
            };
            res: {
                /**
                 * connection successful
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/azure_triggers/namespaces/topics/list/{path}': {
        post: {
            req: {
                path: string;
                requestBody: AzureListTopics;
                workspace: string;
            };
            res: {
                /**
                 * topic list
                 */
                200: Array<{
                    [key: string]: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/azure_triggers/namespaces/subscriptions/list/{path}': {
        post: {
            req: {
                path: string;
                requestBody: AzureListSubscriptions;
                workspace: string;
            };
            res: {
                /**
                 * subscription list
                 */
                200: Array<{
                    [key: string]: unknown;
                }>;
            };
        };
    };
    '/w/{workspace}/azure_triggers/subscriptions/delete/{path}': {
        delete: {
            req: {
                path: string;
                requestBody: AzureDeleteSubscription;
                workspace: string;
            };
            res: {
                /**
                 * subscription deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/azure_triggers/namespaces/list/{path}': {
        post: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * namespace list
                 */
                200: Array<AzureArmResource>;
            };
        };
    };
    '/w/{workspace}/azure_triggers/basic/topics/list/{path}': {
        post: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * topic list
                 */
                200: Array<AzureArmResource>;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/postgres/version/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * postgres version
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/is_valid_postgres_configuration/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * boolean that indicates if postgres is set to logical level or not
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/create_template_script': {
        post: {
            req: {
                /**
                 * template script
                 */
                requestBody: TemplateScript;
                workspace: string;
            };
            res: {
                /**
                 * custom id to retrieve template script
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/get_template_script/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * template script
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/slot/list/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * list postgres slot
                 */
                200: Array<SlotList>;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/slot/create/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * new slot for postgres
                 */
                requestBody: Slot;
                workspace: string;
            };
            res: {
                /**
                 * slot created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/slot/delete/{path}': {
        delete: {
            req: {
                path: string;
                /**
                 * replication slot of postgres
                 */
                requestBody: Slot;
                workspace: string;
            };
            res: {
                /**
                 * postgres replication slot deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/publication/list/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * database publication list
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/publication/get/{publication}/{path}': {
        get: {
            req: {
                path: string;
                /**
                 * The name of the publication
                 */
                publication: string;
                workspace: string;
            };
            res: {
                /**
                 * postgres publication get
                 */
                200: PublicationData;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/publication/create/{publication}/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * The name of the publication
                 */
                publication: string;
                /**
                 * new publication for postgres
                 */
                requestBody: PublicationData;
                workspace: string;
            };
            res: {
                /**
                 * publication created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/publication/update/{publication}/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * The name of the publication
                 */
                publication: string;
                /**
                 * update publication for postgres
                 */
                requestBody: PublicationData;
                workspace: string;
            };
            res: {
                /**
                 * publication updated
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/publication/delete/{publication}/{path}': {
        delete: {
            req: {
                path: string;
                /**
                 * The name of the publication
                 */
                publication: string;
                workspace: string;
            };
            res: {
                /**
                 * postgres publication deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/create': {
        post: {
            req: {
                /**
                 * new postgres trigger
                 */
                requestBody: NewPostgresTrigger;
                workspace: string;
            };
            res: {
                /**
                 * postgres trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditPostgresTrigger;
                workspace: string;
            };
            res: {
                /**
                 * postgres trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * postgres trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * get postgres trigger
                 */
                200: PostgresTrigger;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * postgres trigger list
                 */
                200: Array<PostgresTrigger>;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * postgres trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated postgres trigger enable
                 */
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * postgres trigger enabled set
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/postgres_triggers/test': {
        post: {
            req: {
                /**
                 * test postgres connection
                 */
                requestBody: {
                    database: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * successfuly connected to postgres
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/email_triggers/create': {
        post: {
            req: {
                /**
                 * new email trigger
                 */
                requestBody: NewEmailTrigger;
                workspace: string;
            };
            res: {
                /**
                 * email trigger created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/email_triggers/update/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * updated trigger
                 */
                requestBody: EditEmailTrigger;
                workspace: string;
            };
            res: {
                /**
                 * email trigger updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/email_triggers/delete/{path}': {
        delete: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * email trigger deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/email_triggers/get/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * email trigger retrieved
                 */
                200: EmailTrigger;
            };
        };
    };
    '/w/{workspace}/email_triggers/list': {
        get: {
            req: {
                isFlow?: boolean;
                /**
                 * Filter by label
                 */
                label?: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * filter by path
                 */
                path?: string;
                pathStart?: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * email trigger list
                 */
                200: Array<EmailTrigger>;
            };
        };
    };
    '/w/{workspace}/email_triggers/exists/{path}': {
        get: {
            req: {
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * email trigger exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/email_triggers/local_part_exists': {
        post: {
            req: {
                /**
                 * email local part exists request
                 */
                requestBody: {
                    local_part: string;
                    workspaced_local_part?: boolean;
                    trigger_path?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * email local part exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/email_triggers/setmode/{path}': {
        post: {
            req: {
                path: string;
                requestBody: {
                    mode: TriggerMode;
                    /**
                     * Bypass the parent-state conflict warning when enabling a trigger in a fork whose parent has the same path enabled.
                     *
                     */
                    force?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * email trigger enable/disable
                 */
                200: string;
            };
        };
    };
    '/groups/list': {
        get: {
            res: {
                /**
                 * instance group list
                 */
                200: Array<InstanceGroup>;
            };
        };
    };
    '/groups/list_with_workspaces': {
        get: {
            res: {
                /**
                 * instance group list with workspaces
                 */
                200: Array<InstanceGroupWithWorkspaces>;
            };
        };
    };
    '/groups/get/{name}': {
        get: {
            req: {
                name: string;
            };
            res: {
                /**
                 * instance group
                 */
                200: InstanceGroupWithWorkspaces;
            };
        };
    };
    '/groups/create': {
        post: {
            req: {
                /**
                 * create instance group
                 */
                requestBody: {
                    name: string;
                    summary?: string;
                };
            };
            res: {
                /**
                 * instance group created
                 */
                200: string;
            };
        };
    };
    '/groups/update/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * update instance group
                 */
                requestBody: {
                    new_summary: string;
                    /**
                     * Instance-level role for group members. 'superadmin', 'devops', 'user' or empty to clear.
                     */
                    instance_role?: string | null;
                };
            };
            res: {
                /**
                 * instance group updated
                 */
                200: string;
            };
        };
    };
    '/groups/delete/{name}': {
        delete: {
            req: {
                name: string;
            };
            res: {
                /**
                 * instance group deleted
                 */
                200: string;
            };
        };
    };
    '/groups/adduser/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * user to add to instance group
                 */
                requestBody: {
                    email: string;
                };
            };
            res: {
                /**
                 * user added to instance group
                 */
                200: string;
            };
        };
    };
    '/groups/removeuser/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * user to remove from instance group
                 */
                requestBody: {
                    email: string;
                };
            };
            res: {
                /**
                 * user removed from instance group
                 */
                200: string;
            };
        };
    };
    '/groups/export': {
        get: {
            res: {
                /**
                 * exported instance groups
                 */
                200: Array<ExportedInstanceGroup>;
            };
        };
    };
    '/groups/overwrite': {
        post: {
            req: {
                /**
                 * overwrite instance groups
                 */
                requestBody: Array<ExportedInstanceGroup>;
            };
            res: {
                /**
                 * success message
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/groups/list': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * group list
                 */
                200: Array<Group>;
            };
        };
    };
    '/w/{workspace}/groups/listnames': {
        get: {
            req: {
                /**
                 * only list the groups the user is member of (default false)
                 */
                onlyMemberOf?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * group list
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/groups/create': {
        post: {
            req: {
                /**
                 * create group
                 */
                requestBody: {
                    name: string;
                    summary?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * group created
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/groups/update/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * updated group
                 */
                requestBody: {
                    summary?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * group updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/groups/delete/{name}': {
        delete: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * group deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/groups/get/{name}': {
        get: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * group
                 */
                200: Group;
            };
        };
    };
    '/w/{workspace}/groups/adduser/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * added user to group
                 */
                requestBody: {
                    username?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * user added to group
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/groups/removeuser/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * added user to group
                 */
                requestBody: {
                    username?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * user removed from group
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/groups_history/get/{name}': {
        get: {
            req: {
                name: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * group permission history
                 */
                200: Array<{
                    id?: number;
                    changed_by?: string;
                    changed_at?: string;
                    change_type?: string;
                    member_affected?: string | null;
                }>;
            };
        };
    };
    '/w/{workspace}/folders/list': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * folder list
                 */
                200: Array<Folder>;
            };
        };
    };
    '/w/{workspace}/folders/listnames': {
        get: {
            req: {
                /**
                 * only list the folders the user is member of (default false)
                 */
                onlyMemberOf?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * folder list
                 */
                200: Array<(string)>;
            };
        };
    };
    '/w/{workspace}/folders/create': {
        post: {
            req: {
                /**
                 * create folder
                 */
                requestBody: {
                    name: string;
                    summary?: string;
                    owners?: Array<(string)>;
                    extra_perms?: unknown;
                    default_permissioned_as?: FolderDefaultPermissionedAs;
                };
                workspace: string;
            };
            res: {
                /**
                 * folder created
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/folders/update/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * update folder
                 */
                requestBody: {
                    summary?: string;
                    owners?: Array<(string)>;
                    extra_perms?: unknown;
                    default_permissioned_as?: FolderDefaultPermissionedAs;
                };
                workspace: string;
            };
            res: {
                /**
                 * folder updated
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/folders/delete/{name}': {
        delete: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * folder deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/folders/get/{name}': {
        get: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * folder
                 */
                200: Folder;
            };
        };
    };
    '/w/{workspace}/folders/exists/{name}': {
        get: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * folder exists
                 */
                200: boolean;
            };
        };
    };
    '/w/{workspace}/folders/getusage/{name}': {
        get: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * folder
                 */
                200: {
                    scripts: number;
                    flows: number;
                    apps: number;
                    resources: number;
                    variables: number;
                    schedules: number;
                };
            };
        };
    };
    '/w/{workspace}/folders/addowner/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * owner user to folder
                 */
                requestBody: {
                    owner: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * owner added to folder
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/folders/removeowner/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * added owner to folder
                 */
                requestBody: {
                    owner: string;
                    write?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * owner removed from folder
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/folders_history/get/{name}': {
        get: {
            req: {
                name: string;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workspace: string;
            };
            res: {
                /**
                 * folder permission history
                 */
                200: Array<{
                    id?: number;
                    changed_by?: string;
                    changed_at?: string;
                    change_type?: string;
                    affected?: string | null;
                }>;
            };
        };
    };
    '/configs/list_worker_groups': {
        get: {
            res: {
                /**
                 * a list of worker group configs
                 */
                200: Array<{
                    name: string;
                    config: unknown;
                }>;
            };
        };
    };
    '/configs/list_worker_pools': {
        get: {
            res: {
                /**
                 * a list of worker pool configs
                 */
                200: Array<{
                    name: string;
                    config: unknown;
                }>;
            };
        };
    };
    '/configs/get/{name}': {
        get: {
            req: {
                name: string;
            };
            res: {
                /**
                 * a config
                 */
                200: Configs;
            };
        };
    };
    '/configs/update/{name}': {
        post: {
            req: {
                name: string;
                /**
                 * worker group
                 */
                requestBody: unknown;
            };
            res: {
                /**
                 * Update a worker group
                 */
                200: string;
            };
        };
        delete: {
            req: {
                name: string;
            };
            res: {
                /**
                 * Delete config
                 */
                200: string;
            };
        };
    };
    '/configs/list': {
        get: {
            res: {
                /**
                 * list of configs
                 */
                200: Array<Config>;
            };
        };
    };
    '/configs/list_autoscaling_events/{worker_group}': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                workerGroup: string;
            };
            res: {
                /**
                 * List of autoscaling events
                 */
                200: Array<AutoscalingEvent>;
            };
        };
    };
    '/configs/native_kubernetes_autoscaling_healthcheck': {
        get: {
            res: {
                /**
                 * Kubernetes autoscaling is healthy
                 */
                200: unknown;
                /**
                 * Error
                 */
                400: string;
            };
        };
    };
    '/configs/list_available_python_versions': {
        get: {
            res: {
                /**
                 * List of python versions
                 */
                200: Array<(string)>;
            };
        };
    };
    '/configs/list_all_workspace_dependencies': {
        get: {
            res: {
                /**
                 * a list of workspace dependency summaries
                 */
                200: Array<{
                    workspace_id: string;
                    name?: string;
                    language: ScriptLang;
                }>;
            };
        };
    };
    '/configs/list_all_dedicated_with_deps': {
        get: {
            res: {
                /**
                 * a list of dedicated scripts with workspace dependencies
                 */
                200: Array<{
                    workspace_id: string;
                    path: string;
                    language: ScriptLang;
                    workspace_dep_names: Array<(string)>;
                }>;
            };
        };
    };
    '/agent_workers/create_agent_token': {
        post: {
            req: {
                /**
                 * agent token
                 */
                requestBody: {
                    worker_group: string;
                    tags: Array<(string)>;
                    exp: number;
                };
            };
            res: {
                /**
                 * agent token created
                 */
                200: string;
            };
        };
    };
    '/agent_workers/blacklist_token': {
        post: {
            req: {
                /**
                 * token to blacklist
                 */
                requestBody: {
                    /**
                     * The agent token to blacklist
                     */
                    token: string;
                    /**
                     * Optional expiration date for the blacklist entry
                     */
                    expires_at?: string;
                };
            };
            res: {
                /**
                 * token blacklisted successfully
                 */
                200: unknown;
            };
        };
    };
    '/agent_workers/remove_blacklist_token': {
        post: {
            req: {
                /**
                 * token to remove from blacklist
                 */
                requestBody: {
                    /**
                     * The agent token to remove from blacklist
                     */
                    token: string;
                };
            };
            res: {
                /**
                 * token removed from blacklist successfully
                 */
                200: unknown;
            };
        };
    };
    '/agent_workers/list_blacklisted_tokens': {
        get: {
            req: {
                /**
                 * Whether to include expired blacklisted tokens
                 */
                includeExpired?: boolean;
            };
            res: {
                /**
                 * list of blacklisted tokens
                 */
                200: Array<{
                    /**
                     * The blacklisted token (without prefix)
                     */
                    token: string;
                    /**
                     * When the blacklist entry expires
                     */
                    expires_at: string;
                    /**
                     * When the token was blacklisted
                     */
                    blacklisted_at: string;
                    /**
                     * Email of the user who blacklisted the token
                     */
                    blacklisted_by: string;
                }>;
            };
        };
    };
    '/agent_workers/get_min_version': {
        get: {
            res: {
                /**
                 * minimum worker version
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/acls/get/{kind}/{path}': {
        get: {
            req: {
                kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app' | 'raw_app' | 'http_trigger' | 'websocket_trigger' | 'kafka_trigger' | 'nats_trigger' | 'postgres_trigger' | 'mqtt_trigger' | 'gcp_trigger' | 'azure_trigger' | 'sqs_trigger' | 'email_trigger' | 'volume';
                path: string;
                workspace: string;
            };
            res: {
                /**
                 * acls
                 */
                200: {
                    [key: string]: (boolean);
                };
            };
        };
    };
    '/w/{workspace}/acls/add/{kind}/{path}': {
        post: {
            req: {
                kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app' | 'raw_app' | 'http_trigger' | 'websocket_trigger' | 'kafka_trigger' | 'nats_trigger' | 'postgres_trigger' | 'mqtt_trigger' | 'gcp_trigger' | 'azure_trigger' | 'sqs_trigger' | 'email_trigger' | 'volume';
                path: string;
                /**
                 * acl to add
                 */
                requestBody: {
                    owner: string;
                    write?: boolean;
                };
                workspace: string;
            };
            res: {
                /**
                 * granular acl added
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/acls/remove/{kind}/{path}': {
        post: {
            req: {
                kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app' | 'raw_app' | 'http_trigger' | 'websocket_trigger' | 'kafka_trigger' | 'nats_trigger' | 'postgres_trigger' | 'mqtt_trigger' | 'gcp_trigger' | 'azure_trigger' | 'sqs_trigger' | 'email_trigger' | 'volume';
                path: string;
                /**
                 * acl to add
                 */
                requestBody: {
                    owner: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * granular acl removed
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/capture/set_config': {
        post: {
            req: {
                /**
                 * capture config
                 */
                requestBody: {
                    trigger_kind: CaptureTriggerKind;
                    path: string;
                    is_flow: boolean;
                    trigger_config?: {
                        [key: string]: unknown;
                    };
                };
                workspace: string;
            };
            res: {
                /**
                 * capture config set
                 */
                200: {
                    [key: string]: unknown;
                };
            };
        };
    };
    '/w/{workspace}/capture/ping_config/{trigger_kind}/{runnable_kind}/{path}': {
        post: {
            req: {
                path: string;
                runnableKind: 'script' | 'flow';
                triggerKind: CaptureTriggerKind;
                workspace: string;
            };
            res: {
                /**
                 * capture config pinged
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/capture/get_configs/{runnable_kind}/{path}': {
        get: {
            req: {
                path: string;
                runnableKind: 'script' | 'flow';
                workspace: string;
            };
            res: {
                /**
                 * capture configs for a script or flow
                 */
                200: Array<CaptureConfig>;
            };
        };
    };
    '/w/{workspace}/capture/list/{runnable_kind}/{path}': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                path: string;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                runnableKind: 'script' | 'flow';
                triggerKind?: CaptureTriggerKind;
                workspace: string;
            };
            res: {
                /**
                 * list of captures for a script or flow
                 */
                200: Array<Capture>;
            };
        };
    };
    '/w/{workspace}/capture/move/{runnable_kind}/{path}': {
        post: {
            req: {
                path: string;
                /**
                 * move captures and configs to a new path
                 */
                requestBody: {
                    new_path?: string;
                };
                runnableKind: 'script' | 'flow';
                workspace: string;
            };
            res: {
                /**
                 * captures and configs moved
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/capture/{id}': {
        get: {
            req: {
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * capture
                 */
                200: Capture;
            };
        };
        delete: {
            req: {
                id: number;
                workspace: string;
            };
            res: {
                /**
                 * capture deleted
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/favorites/star': {
        post: {
            req: {
                requestBody?: {
                    path?: string;
                    favorite_kind?: 'flow' | 'app' | 'script' | 'raw_app' | 'asset' | 'bpmn_flow';
                };
                workspace: string;
            };
            res: {
                /**
                 * star item
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/favorites/unstar': {
        post: {
            req: {
                requestBody?: {
                    path?: string;
                    favorite_kind?: 'flow' | 'app' | 'script' | 'raw_app' | 'asset' | 'bpmn_flow';
                };
                workspace: string;
            };
            res: {
                /**
                 * unstar item
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/inputs/history': {
        get: {
            req: {
                /**
                 * filter on jobs containing those args as a json subset (@> in postgres)
                 */
                args?: string;
                includePreview?: boolean;
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                runnableId?: string;
                runnableType?: RunnableType;
                workspace: string;
            };
            res: {
                /**
                 * Input history for completed jobs
                 */
                200: Array<Input>;
            };
        };
    };
    '/w/{workspace}/inputs/{jobOrInputId}/args': {
        get: {
            req: {
                allowLarge?: boolean;
                input?: boolean;
                jobOrInputId: string;
                workspace: string;
            };
            res: {
                /**
                 * args
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/inputs/list': {
        get: {
            req: {
                /**
                 * which page to return (start at 1, default 1)
                 */
                page?: number;
                /**
                 * number of items to return for a given page (default 30, max 100)
                 */
                perPage?: number;
                runnableId?: string;
                runnableType?: RunnableType;
                workspace: string;
            };
            res: {
                /**
                 * Saved Inputs for a Runnable
                 */
                200: Array<Input>;
            };
        };
    };
    '/w/{workspace}/inputs/create': {
        post: {
            req: {
                /**
                 * Input
                 */
                requestBody: CreateInput;
                runnableId?: string;
                runnableType?: RunnableType;
                workspace: string;
            };
            res: {
                /**
                 * Input created
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/inputs/update': {
        post: {
            req: {
                /**
                 * UpdateInput
                 */
                requestBody: UpdateInput;
                workspace: string;
            };
            res: {
                /**
                 * Input updated
                 */
                201: string;
            };
        };
    };
    '/w/{workspace}/inputs/delete/{input}': {
        post: {
            req: {
                input: string;
                workspace: string;
            };
            res: {
                /**
                 * Input deleted
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/job_helpers/duckdb_connection_settings': {
        post: {
            req: {
                /**
                 * S3 resource to connect to
                 */
                requestBody: {
                    s3_resource?: S3Resource;
                };
                workspace: string;
            };
            res: {
                /**
                 * Connection settings
                 */
                200: {
                    connection_settings_str?: string;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/v2/duckdb_connection_settings': {
        post: {
            req: {
                /**
                 * S3 resource path to use to generate the connection settings. If empty, the S3 resource defined in the workspace settings will be used
                 */
                requestBody: {
                    s3_resource_path?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * Connection settings
                 */
                200: {
                    connection_settings_str: string;
                    azure_container_path?: string;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/polars_connection_settings': {
        post: {
            req: {
                /**
                 * S3 resource to connect to
                 */
                requestBody: {
                    s3_resource?: S3Resource;
                };
                workspace: string;
            };
            res: {
                /**
                 * Connection settings
                 */
                200: {
                    endpoint_url: string;
                    key?: string;
                    secret?: string;
                    use_ssl: boolean;
                    cache_regions: boolean;
                    client_kwargs: PolarsClientKwargs;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/v2/polars_connection_settings': {
        post: {
            req: {
                /**
                 * S3 resource path to use to generate the connection settings. If empty, the S3 resource defined in the workspace settings will be used
                 */
                requestBody: {
                    s3_resource_path?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * Connection settings
                 */
                200: {
                    s3fs_args: {
                        endpoint_url: string;
                        key?: string;
                        secret?: string;
                        use_ssl: boolean;
                        cache_regions: boolean;
                        client_kwargs: PolarsClientKwargs;
                    };
                    storage_options: {
                        aws_endpoint_url: string;
                        aws_access_key_id?: string;
                        aws_secret_access_key?: string;
                        aws_region: string;
                        aws_allow_http: string;
                    };
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/v2/s3_resource_info': {
        post: {
            req: {
                /**
                 * S3 resource path to use. If empty, the S3 resource defined in the workspace settings will be used
                 */
                requestBody: {
                    s3_resource_path?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * Connection settings
                 */
                200: S3Resource;
            };
        };
    };
    '/w/{workspace}/job_helpers/test_connection': {
        get: {
            req: {
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * Connection settings
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/job_helpers/list_stored_files': {
        get: {
            req: {
                marker?: string;
                maxKeys: number;
                prefix?: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * List of file keys
                 */
                200: {
                    next_marker?: string;
                    orvanta_large_files: Array<OrvantaLargeFile>;
                    restricted_access?: boolean;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/load_file_metadata': {
        get: {
            req: {
                fileKey: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * FileMetadata
                 */
                200: OrvantaFileMetadata;
            };
        };
    };
    '/w/{workspace}/job_helpers/load_file_preview': {
        get: {
            req: {
                csvHasHeader?: boolean;
                csvSeparator?: string;
                fileKey: string;
                fileMimeType?: string;
                fileSizeInBytes?: number;
                readBytesFrom?: number;
                readBytesLength?: number;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * FilePreview
                 */
                200: OrvantaFilePreview;
            };
        };
    };
    '/w/{workspace}/job_helpers/list_git_repo_files': {
        get: {
            req: {
                marker?: string;
                maxKeys: number;
                prefix?: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * List of file keys
                 */
                200: {
                    next_marker?: string;
                    orvanta_large_files: Array<OrvantaLargeFile>;
                    restricted_access?: boolean;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/load_git_repo_file_preview': {
        get: {
            req: {
                csvHasHeader?: boolean;
                csvSeparator?: string;
                fileKey: string;
                fileMimeType?: string;
                fileSizeInBytes?: number;
                readBytesFrom?: number;
                readBytesLength?: number;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * FilePreview
                 */
                200: OrvantaFilePreview;
            };
        };
    };
    '/w/{workspace}/job_helpers/load_git_repo_file_metadata': {
        get: {
            req: {
                fileKey: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * FileMetadata
                 */
                200: OrvantaFileMetadata;
            };
        };
    };
    '/w/{workspace}/job_helpers/check_s3_folder_exists': {
        get: {
            req: {
                /**
                 * S3 file key to check (e.g., gitrepos/{workspace_id}/u/user/resource/{commit_hash})
                 */
                fileKey: string;
                /**
                 * If provided, the folder is only considered to exist when this exact
                 * sentinel file is present under file_key. Lets callers distinguish a
                 * fully populated folder from a partial upload.
                 *
                 */
                markerFile?: string;
                workspace: string;
            };
            res: {
                /**
                 * S3 folder existence check result
                 */
                200: {
                    /**
                     * Whether the path exists
                     */
                    exists: boolean;
                    /**
                     * Whether the path is a folder (true) or file (false)
                     */
                    is_folder: boolean;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/load_parquet_preview/{path}': {
        get: {
            req: {
                limit?: number;
                offset?: number;
                path: string;
                searchCol?: string;
                searchTerm?: string;
                sortCol?: string;
                sortDesc?: boolean;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * Parquet Preview
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/job_helpers/load_table_count/{path}': {
        get: {
            req: {
                path: string;
                searchCol?: string;
                searchTerm?: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * Table count
                 */
                200: {
                    count?: number;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/load_csv_preview/{path}': {
        get: {
            req: {
                csvSeparator?: string;
                limit?: number;
                offset?: number;
                path: string;
                searchCol?: string;
                searchTerm?: string;
                sortCol?: string;
                sortDesc?: boolean;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * Csv Preview
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/job_helpers/delete_s3_file': {
        delete: {
            req: {
                fileKey: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * Confirmation
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/job_helpers/move_s3_file': {
        get: {
            req: {
                destFileKey: string;
                srcFileKey: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * Confirmation
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/job_helpers/upload_s3_file': {
        post: {
            req: {
                contentDisposition?: string;
                contentType?: string;
                fileExtension?: string;
                fileKey?: string;
                /**
                 * File content
                 */
                requestBody: (Blob | File);
                resourceType?: string;
                s3ResourcePath?: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * File upload status
                 */
                200: {
                    file_key: string;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/upload_git_repo_file_to_instance_storage': {
        post: {
            req: {
                contentDisposition?: string;
                contentType?: string;
                fileExtension?: string;
                fileKey?: string;
                /**
                 * File content
                 */
                requestBody: (Blob | File);
                resourceType?: string;
                s3ResourcePath?: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * File upload status
                 */
                200: {
                    file_key: string;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/download_s3_file': {
        get: {
            req: {
                fileKey: string;
                resourceType?: string;
                s3ResourcePath?: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * Chunk of the downloaded file
                 */
                200: (Blob | File);
            };
        };
    };
    '/w/{workspace}/job_helpers/download_s3_parquet_file_as_csv': {
        get: {
            req: {
                fileKey: string;
                resourceType?: string;
                s3ResourcePath?: string;
                workspace: string;
            };
            res: {
                /**
                 * The downloaded file
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/job_metrics/get/{id}': {
        post: {
            req: {
                id: string;
                /**
                 * parameters for statistics retrieval
                 */
                requestBody: {
                    timeseries_max_datapoints?: number;
                    from_timestamp?: string;
                    to_timestamp?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * job details
                 */
                200: {
                    metrics_metadata?: Array<MetricMetadata>;
                    scalar_metrics?: Array<ScalarMetric>;
                    timeseries_metrics?: Array<TimeseriesMetric>;
                };
            };
        };
    };
    '/w/{workspace}/job_metrics/set_progress/{id}': {
        post: {
            req: {
                id: string;
                /**
                 * parameters for statistics retrieval
                 */
                requestBody: {
                    percent?: number;
                    flow_job_id?: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * Job progress updated
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/job_metrics/get_progress/{id}': {
        get: {
            req: {
                id: string;
                workspace: string;
            };
            res: {
                /**
                 * job progress between 0 and 99
                 */
                200: number;
            };
        };
    };
    '/service_logs/list_files': {
        get: {
            req: {
                /**
                 * filter on created after (exclusive) timestamp
                 */
                after?: string;
                /**
                 * filter on started before (inclusive) timestamp
                 */
                before?: string;
                withError?: boolean;
            };
            res: {
                /**
                 * time
                 */
                200: Array<{
                    hostname: string;
                    mode: string;
                    worker_group?: string;
                    log_ts: string;
                    file_path: string;
                    ok_lines?: number;
                    err_lines?: number;
                    json_fmt: boolean;
                }>;
            };
        };
    };
    '/service_logs/get_log_file/{path}': {
        get: {
            req: {
                path: string;
            };
            res: {
                /**
                 * log stream
                 */
                200: string;
            };
        };
    };
    '/concurrency_groups/list': {
        get: {
            res: {
                /**
                 * all concurrency groups
                 */
                200: Array<ConcurrencyGroup>;
            };
        };
    };
    '/concurrency_groups/prune/{concurrency_id}': {
        delete: {
            req: {
                concurrencyId: string;
            };
            res: {
                /**
                 * concurrency group removed
                 */
                200: unknown;
            };
        };
    };
    '/concurrency_groups/{id}/key': {
        get: {
            req: {
                id: string;
            };
            res: {
                /**
                 * concurrency key for given job
                 */
                200: string;
            };
        };
    };
    '/srch/w/{workspace}/index/search/job': {
        get: {
            req: {
                paginationOffset?: number;
                searchQuery: string;
                workspace: string;
            };
            res: {
                /**
                 * search results
                 */
                200: {
                    /**
                     * a list of the terms that couldn't be parsed (and thus ignored)
                     */
                    query_parse_errors?: Array<(string)>;
                    /**
                     * the jobs that matched the query
                     */
                    hits?: Array<JobSearchHit>;
                    /**
                     * how many jobs matched in total
                     */
                    hit_count?: number;
                    /**
                     * Metadata about the index current state
                     */
                    index_metadata?: {
                        /**
                         * Datetime of the most recently indexed job
                         */
                        indexed_until?: string;
                        /**
                         * Is the current indexer service being replaced
                         */
                        lost_lock_ownership?: boolean;
                        /**
                         * Maximum time window in seconds for indexing
                         */
                        max_index_time_window_secs?: number;
                    };
                };
            };
        };
    };
    '/srch/index/search/service_logs': {
        get: {
            req: {
                hostname: string;
                maxTs?: string;
                minTs?: string;
                mode: string;
                searchQuery: string;
                workerGroup?: string;
            };
            res: {
                /**
                 * search results
                 */
                200: {
                    /**
                     * a list of the terms that couldn't be parsed (and thus ignored)
                     */
                    query_parse_errors?: Array<(string)>;
                    /**
                     * log files that matched the query
                     */
                    hits?: Array<LogSearchHit>;
                };
            };
        };
    };
    '/srch/index/search/count_service_logs': {
        get: {
            req: {
                maxTs?: string;
                minTs?: string;
                searchQuery: string;
            };
            res: {
                /**
                 * search results
                 */
                200: {
                    /**
                     * a list of the terms that couldn't be parsed (and thus ignored)
                     */
                    query_parse_errors?: Array<(string)>;
                    /**
                     * count of log lines that matched the query per hostname
                     */
                    count_per_host?: {
                        [key: string]: unknown;
                    };
                };
            };
        };
    };
    '/srch/index/storage/disk': {
        get: {
            res: {
                /**
                 * disk storage sizes for each index
                 */
                200: {
                    job_index_disk_size_bytes?: number | null;
                    log_index_disk_size_bytes?: number | null;
                };
            };
        };
    };
    '/indexer/delete/{idx_name}': {
        delete: {
            req: {
                idxName: 'JobIndex' | 'ServiceLogIndex';
            };
            res: {
                /**
                 * idx to be deleted and indexer restarting
                 */
                200: string;
            };
        };
    };
    '/indexer/storage': {
        get: {
            res: {
                /**
                 * storage sizes for each index
                 */
                200: {
                    job_index?: {
                        disk_size_bytes?: number | null;
                        s3_size_bytes?: number | null;
                    };
                    service_log_index?: {
                        disk_size_bytes?: number | null;
                        s3_size_bytes?: number | null;
                    };
                };
            };
        };
    };
    '/indexer/status': {
        get: {
            res: {
                /**
                 * indexer status for each index
                 */
                200: {
                    job_indexer?: {
                        is_alive?: boolean;
                        last_locked_at?: string | null;
                        owner?: string | null;
                        storage?: {
                            disk_size_bytes?: number | null;
                            s3_size_bytes?: number | null;
                        };
                    };
                    log_indexer?: {
                        is_alive?: boolean;
                        last_locked_at?: string | null;
                        owner?: string | null;
                        storage?: {
                            disk_size_bytes?: number | null;
                            s3_size_bytes?: number | null;
                        };
                    };
                };
            };
        };
    };
    '/w/{workspace}/assets/list': {
        get: {
            req: {
                /**
                 * Filter by asset kinds (multiple values allowed)
                 */
                assetKinds?: string;
                /**
                 * Filter by asset path (case-insensitive partial match)
                 */
                assetPath?: string;
                /**
                 * broad search across multiple fields (case-insensitive substring match)
                 */
                broadFilter?: string;
                /**
                 * JSONB subset match filter for columns using base64 encoded JSON
                 */
                columns?: string;
                /**
                 * Cursor timestamp for pagination (created_at of last item from previous page)
                 */
                cursorCreatedAt?: string;
                /**
                 * Cursor ID for pagination (id of last item from previous page)
                 */
                cursorId?: number;
                /**
                 * exact path match filter
                 */
                path?: string;
                /**
                 * Number of items per page (max 1000, default 50)
                 */
                perPage?: number;
                /**
                 * Filter by usage path (case-insensitive partial match)
                 */
                usagePath?: string;
                workspace: string;
            };
            res: {
                /**
                 * paginated assets in the workspace
                 */
                200: {
                    assets: Array<{
                        path: string;
                        kind: AssetKind;
                        usages: Array<{
                            path: string;
                            kind: AssetUsageKind;
                            access_type?: AssetUsageAccessType;
                            /**
                             * The columns used (for tables)
                             */
                            columns?: {
                                [key: string]: AssetUsageAccessType;
                            };
                            /**
                             * When the asset was detected
                             */
                            created_at?: string;
                            metadata?: {
                                /**
                                 * The path of the script/flow that was run (only present when kind is 'job')
                                 */
                                runnable_path?: string;
                                /**
                                 * The kind of job (script, flow, preview, etc.) (only present when kind is 'job')
                                 */
                                job_kind?: string;
                            };
                        }>;
                        metadata?: {
                            /**
                             * The type of the resource (only present when kind is 'resource')
                             */
                            resource_type?: string;
                        };
                    }>;
                    /**
                     * Cursor for the next page (null if no more pages)
                     */
                    next_cursor?: {
                        /**
                         * Timestamp to use for next page
                         */
                        created_at?: string;
                        /**
                         * ID to use for next page
                         */
                        id?: number;
                    } | null;
                };
            };
        };
    };
    '/w/{workspace}/assets/list_by_usages': {
        post: {
            req: {
                /**
                 * list assets by usages
                 */
                requestBody: {
                    usages: Array<{
                        path: string;
                        kind: AssetUsageKind;
                    }>;
                };
                workspace: string;
            };
            res: {
                /**
                 * all assets used by the given usage paths, in the same order
                 */
                200: Array<Array<{
                    path: string;
                    kind: AssetKind;
                    access_type?: AssetUsageAccessType;
                }>>;
            };
        };
    };
    '/w/{workspace}/assets/list_favorites': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of favorite assets
                 */
                200: Array<{
                    /**
                     * The asset path
                     */
                    path: string;
                }>;
            };
        };
    };
    '/w/{workspace}/volumes/list': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of volumes
                 */
                200: Array<Volume>;
            };
        };
    };
    '/w/{workspace}/volumes/storage': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * volume storage name or null
                 */
                200: string | null;
            };
        };
    };
    '/w/{workspace}/volumes/create': {
        post: {
            req: {
                requestBody: {
                    name: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * volume created
                 */
                200: string;
            };
        };
    };
    '/w/{workspace}/volumes/delete/{name}': {
        delete: {
            req: {
                name: string;
                workspace: string;
            };
            res: {
                /**
                 * volume deleted
                 */
                200: string;
            };
        };
    };
    '/mcp/w/{workspace}/list_tools': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * list of MCP tools available for the workspace
                 */
                200: Array<EndpointTool>;
            };
        };
    };
    '/mcp/oauth/discover': {
        post: {
            req: {
                requestBody: {
                    /**
                     * URL of the MCP server to discover OAuth metadata from
                     */
                    mcp_server_url: string;
                };
            };
            res: {
                /**
                 * OAuth metadata from MCP server
                 */
                200: {
                    scopes_supported?: Array<(string)>;
                    authorization_endpoint?: string;
                    token_endpoint?: string;
                    registration_endpoint?: string;
                    supports_dynamic_registration?: boolean;
                };
            };
        };
    };
    '/mcp/oauth/start': {
        get: {
            req: {
                /**
                 * URL of the MCP server to connect to
                 */
                mcpServerUrl: string;
                /**
                 * Comma/whitespace-separated list of OAuth scopes to request
                 */
                scopes?: string;
                /**
                 * Workspace the resulting connection will belong to
                 */
                workspaceId: string;
            };
            res: {
                /**
                 * Redirect to OAuth provider authorization URL
                 */
                302: unknown;
            };
        };
    };
    '/mcp/oauth/callback': {
        get: {
            req: {
                /**
                 * OAuth authorization code (absent when the authorization server reports an error instead)
                 */
                code?: string;
                /**
                 * Error code from the authorization server, if the user denied access or the request failed
                 */
                error?: string;
                errorDescription?: string;
                /**
                 * CSRF state token, single-use, matched against the row created by /mcp/oauth/start
                 */
                state: string;
            };
            res: {
                /**
                 * HTML page with JavaScript that posts a success/error message to the opener window and closes
                 */
                200: string;
            };
        };
    };
    '/mcp/oauth/refresh': {
        post: {
            req: {
                requestBody: {
                    workspace_id: string;
                    mcp_server_url: string;
                };
            };
            res: {
                /**
                 * Token refreshed
                 */
                200: {
                    expires_in?: number | null;
                };
            };
        };
    };
    '/mcp/oauth/client-metadata.json': {
        get: {
            res: {
                /**
                 * Client metadata
                 */
                200: {
                    client_name?: string;
                    redirect_uris?: Array<(string)>;
                    grant_types?: Array<(string)>;
                    response_types?: Array<(string)>;
                    token_endpoint_auth_method?: string;
                };
            };
        };
    };
};