/**
 * 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;
    /**
     * 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>;
};
/**
 * 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 shown when stopping
     */
    error_message?: string;
};
/**
 * 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 true, this step's result is deleted after use to save memory
     */
    delete_after_use?: boolean;
    /**
     * 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;
};
/**
 * 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' | 'duckdb';
    /**
     * 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 image references for vision-capable models.
         * Format: Array<{ bucket: string, key: string }> - S3 object references
         * Example: [{ bucket: 'my-bucket', key: 'images/photo.jpg' }]
         *
         */
        user_images?: 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, 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)>;
};
/**
 * 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., "EE 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)>;
};
/**
 * 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., windmill)
     */
    mount_path: string;
    /**
     * Vault JWT auth role name for Windmill (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;
};
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;
    /**
     * 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' | '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 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;
    delete_after_use?: boolean;
    visible_to_runner_only?: boolean;
    no_main_func: boolean;
    codebase?: string;
    has_preprocessor: boolean;
    on_behalf_of_email?: 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;
    delete_after_use?: boolean;
    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;
    no_main_func?: boolean;
    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';
    }>;
};
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;
    workflow_as_code_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;
    workflow_as_code_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;
    };
    workflow_as_code_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;
    };
    workflow_as_code_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;
};
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 TruncatedToken = {
    label?: string;
    expiration?: string;
    token_prefix: string;
    created_at: string;
    last_used_at: string;
    scopes?: Array<(string)>;
    email?: 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 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;
};
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;
};
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;
};
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;
    }>;
    no_main_func: boolean | 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' | 'duckdb' | 'bunnative';
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;
};
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;
};
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;
};
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;
};
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;
};
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 path identifier for this schedule
     */
    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;
    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;
    /**
     * 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;
};
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 path identifier for this schedule
     */
    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;
    /**
     * Email of the user who the scheduled jobs run as. Used during deployment to preserve the original schedule owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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;
    /**
     * Email of the user who the scheduled jobs run as. Used during deployment to preserve the original schedule owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
/**
 * job trigger kind (schedule, http, websocket...)
 */
export type JobTriggerKind = 'webhook' | 'default_email' | 'email' | 'schedule' | 'http' | 'websocket' | 'postgres' | 'kafka' | 'nats' | 'mqtt' | 'sqs' | 'gcp' | 'google';
/**
 * job trigger mode
 */
export type TriggerMode = 'enabled' | 'disabled' | 'suspended';
export type TriggerExtraProperty = {
    /**
     * The unique path identifier for this trigger
     */
    path: string;
    /**
     * Path to the script or flow to execute when triggered
     */
    script_path: string;
    /**
     * Email of the user who owns this trigger, used for permissioned_as
     */
    email: 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;
};
export type AuthenticationMethod = 'none' | 'windmill' | '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), 'windmill' (Windmill 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 path identifier for this trigger
     */
    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), 'windmill' (Windmill 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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
export type EditHttpTrigger = {
    /**
     * The unique path identifier for this trigger
     */
    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), 'windmill' (Windmill 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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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;
    sqs_count?: number;
    nextcloud_count?: number;
    google_count?: number;
};
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;
    }>;
    /**
     * 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;
    /**
     * 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 path identifier for this trigger
     */
    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;
    }>;
    /**
     * 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;
    /**
     * 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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
export type EditWebsocketTrigger = {
    /**
     * The WebSocket URL to connect to (can be a static URL or computed by a runnable)
     */
    url: string;
    /**
     * The unique path identifier for this trigger
     */
    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;
    }>;
    /**
     * 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;
    /**
     * 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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
/**
 * 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 path identifier for this trigger.
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
export type GetAllTopicSubscription = {
    topic_id: string;
};
export type DeleteGcpSubscription = {
    subscription_id: 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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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;
    }>;
    /**
     * 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 path identifier for this trigger
     */
    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;
    }>;
    /**
     * 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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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;
    }>;
    /**
     * 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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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 path identifier for this trigger
     */
    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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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;
    /**
     * Email of the user who triggered jobs run as. Used during deployment to preserve the original trigger owner.
     */
    email?: string;
    /**
     * When true and the caller is a member of the 'wm_deployers' group, preserves the original email value instead of overwriting it.
     */
    preserve_email?: boolean;
};
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)>;
};
export type InstanceGroupWithWorkspaces = {
    name: string;
    summary?: string;
    emails?: Array<(string)>;
    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;
};
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;
};
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;
};
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;
};
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;
};
export type FlowPreview = {
    value: FlowValue;
    path?: string;
    args: ScriptArgs;
    tag?: string;
    restarted_from?: RestartedFrom;
};
export type RestartedFrom = {
    flow_job_id?: string;
    step_id?: string;
    branch_or_iteration_n?: number;
    flow_version?: number;
};
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;
};
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;
};
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;
};
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 SlackToken = {
    access_token: string;
    team_id: string;
    team_name: string;
    bot: {
        bot_access_token?: 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;
            };
        };
    };
};
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 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 WindmillLargeFile = {
    s3: string;
};
export type WindmillFileMetadata = {
    mime_type?: string;
    size_in_bytes?: number;
    last_modified?: string;
    expires?: string;
    version_id?: string;
};
export type WindmillFilePreview = {
    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;
    force_branch?: string;
    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;
};
/**
 * 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;
};
export type JobSearchHit = {
    dancer?: string;
};
export type LogSearchHit = {
    dancer?: string;
};
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' | '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' | 'resource' | 'variable' | 'resource_type';
    /**
     * 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 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';
/**
 * Groups that can bypass this ruleset
 */
export type RuleBypasserGroups = Array<(string)>;
/**
 * Users that can bypass this ruleset
 */
export type RuleBypasserUsers = Array<(string)>;
export type NativeServiceName = 'nextcloud' | 'google';
/**
 * A native trigger stored in Windmill
 */
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;
};
/**
 * Full trigger response containing both Windmill 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;
    /**
     * 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;
    };
};
/**
 * 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_windmill: 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 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;
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 BackendUptodateResponse = string;
export type GetLicenseIdResponse = string;
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 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;
    };
};
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;
    };
};
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 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 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 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 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 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;
};
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 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 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 GetPremiumInfoData = {
    /**
     * skip fetching subscription status from stripe
     */
    skipSubscriptionFetch?: boolean;
    workspace: string;
};
export type GetPremiumInfoResponse = {
    premium: boolean;
    usage?: number;
    owner: string;
    status?: string;
    is_past_due: boolean;
    max_tolerated_executions?: number;
};
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 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 = {
    /**
     * WorkspaceInvite
     */
    requestBody: {
        slack_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 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;
    };
    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 = string;
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<(string)>;
export type ListDataTableSchemasData = {
    workspace: string;
};
export type ListDataTableSchemasResponse = Array<DataTableSchema>;
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 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;
};
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;
    sqs_used: boolean;
    email_used: boolean;
    nextcloud_used: boolean;
    google_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 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 GetGlobalData = {
    key: string;
};
export type GetGlobalResponse = unknown;
export type SetGlobalData = {
    key: string;
    /**
     * value set
     */
    requestBody: {
        value?: unknown;
    };
};
export type SetGlobalResponse = 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 TestObjectStorageConfigData = {
    /**
     * test object storage config
     */
    requestBody: {
        [key: string]: unknown;
    };
};
export type TestObjectStorageConfigResponse = string;
export type SendStatsResponse = string;
export type GetStatsResponse = 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 ListGlobalSettingsResponse = Array<GlobalSetting>;
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 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;
    /**
     * 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 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 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;
    };
    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;
};
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;
    /**
     * 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 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;
    /**
     * 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;
    /**
     * 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;
    };
    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;
        };
        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;
    };
    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;
        };
        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;
        };
        id?: number;
        force_viewer_static_fields?: {
            [key: string]: unknown;
        };
        force_viewer_one_of_fields?: {
            [key: string]: unknown;
        };
        force_viewer_allow_user_resources?: Array<(string)>;
        /**
         * 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 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 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 CreateDraftData = {
    requestBody: {
        path: string;
        typ: 'flow' | 'script' | 'app';
        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: {
        /**
         * step id to restart the flow from
         */
        step_id: string;
        /**
         * for branchall or loop, 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;
    };
    /**
     * 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 RunCodeWorkflowTaskData = {
    entrypoint: string;
    jobId: string;
    /**
     * preview
     */
    requestBody: WorkflowTask;
    workspace: string;
};
export type RunCodeWorkflowTaskResponse = string;
export type RunRawScriptDependenciesData = {
    /**
     * raw script content
     */
    requestBody: {
        raw_scripts: Array<RawScriptForDependencies>;
        entrypoint: string;
    };
    workspace: string;
};
export type RunRawScriptDependenciesResponse = {
    lock: 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 = {
    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 = {
    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 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;
    workflow_as_code_status?: WorkflowStatus;
};
export type GetJobUpdatesSseData = {
    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;
    cancelButtonText?: string;
    channelName: string;
    defaultArgsJson?: string;
    dynamicEnumsJson?: string;
    flowStepId: string;
    id: string;
    message?: string;
    resumeButtonText?: string;
    teamName: string;
    workspace: string;
};
export type GetTeamsApprovalPayloadResponse = unknown;
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 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 = {
    /**
     * id to fetch only the messages after that id
     */
    afterId?: string;
    /**
     * 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 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;
    /**
     * 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;
    };
};
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;
    };
    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;
    /**
     * 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;
    /**
     * 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;
    };
    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;
    /**
     * 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;
    };
    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;
    /**
     * 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;
    };
    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;
    /**
     * 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;
    };
    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;
    /**
     * 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;
    };
    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;
    /**
     * 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 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;
    /**
     * 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;
    };
    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;
    /**
     * 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;
    };
    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 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;
    /**
     * 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;
    };
    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;
    /**
     * 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;
    };
    workspace: string;
};
export type SetEmailTriggerModeResponse = string;
export type ListInstanceGroupsResponse = Array<InstanceGroup>;
export type ListInstanceGroupsWithWorkspacesResponse = Array<InstanceGroupWithWorkspaces>;
export type GetInstanceGroupData = {
    name: string;
};
export type GetInstanceGroupResponse = InstanceGroup;
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;
    };
};
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;
    };
    workspace: string;
};
export type CreateFolderResponse = string;
export type UpdateFolderData = {
    name: string;
    /**
     * update folder
     */
    requestBody: {
        summary?: string;
        owners?: Array<(string)>;
        extra_perms?: unknown;
    };
    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 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 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' | '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' | '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' | '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';
    };
    workspace: string;
};
export type StarResponse = unknown;
export type UnstarData = {
    requestBody?: {
        path?: string;
        favorite_kind?: 'flow' | 'app' | 'script' | 'raw_app' | 'asset';
    };
    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;
    windmill_large_files: Array<WindmillLargeFile>;
    restricted_access?: boolean;
};
export type LoadFileMetadataData = {
    fileKey: string;
    storage?: string;
    workspace: string;
};
export type LoadFileMetadataResponse = WindmillFileMetadata;
export type LoadFilePreviewData = {
    csvHasHeader?: boolean;
    csvSeparator?: string;
    fileKey: string;
    fileMimeType?: string;
    fileSizeInBytes?: number;
    readBytesFrom?: number;
    readBytesLength?: number;
    storage?: string;
    workspace: string;
};
export type LoadFilePreviewResponse = WindmillFilePreview;
export type ListGitRepoFilesData = {
    marker?: string;
    maxKeys: number;
    prefix?: string;
    storage?: string;
    workspace: string;
};
export type ListGitRepoFilesResponse = {
    next_marker?: string;
    windmill_large_files: Array<WindmillLargeFile>;
    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 = WindmillFilePreview;
export type LoadGitRepoFileMetadataData = {
    fileKey: string;
    storage?: string;
    workspace: string;
};
export type LoadGitRepoFileMetadataResponse = WindmillFileMetadata;
export type CheckS3FolderExistsData = {
    /**
     * S3 file key to check (e.g., gitrepos/{workspace_id}/u/user/resource/{commit_hash})
     */
    fileKey: 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 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-separated list of OAuth scopes to request
     */
    scopes?: string;
};
export type McpOauthCallbackData = {
    /**
     * OAuth authorization code
     */
    code: string;
    /**
     * CSRF state token
     */
    state: string;
};
export type McpOauthCallbackResponse = string;
export type $OpenApiTs = {
    '/version': {
        get: {
            res: {
                /**
                 * git version of backend
                 */
                200: string;
            };
        };
    };
    '/uptodate': {
        get: {
            res: {
                /**
                 * is backend up to date
                 */
                200: string;
            };
        };
    };
    '/ee_license': {
        get: {
            res: {
                /**
                 * get license id (empty if not ee)
                 */
                200: string;
            };
        };
    };
    '/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/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;
                };
            };
            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;
                };
            };
            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/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/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/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/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/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;
                };
            };
        };
    };
    '/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/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_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/premium_info': {
        get: {
            req: {
                /**
                 * skip fetching subscription status from stripe
                 */
                skipSubscriptionFetch?: boolean;
                workspace: string;
            };
            res: {
                /**
                 * status
                 */
                200: {
                    premium: boolean;
                    usage?: number;
                    owner: string;
                    status?: string;
                    is_past_due: boolean;
                    max_tolerated_executions?: number;
                };
            };
        };
    };
    '/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_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: {
                /**
                 * WorkspaceInvite
                 */
                requestBody: {
                    slack_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/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;
                };
                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: string;
            };
        };
    };
    '/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<(string)>;
            };
        };
    };
    '/w/{workspace}/workspaces/list_datatable_schemas': {
        get: {
            req: {
                workspace: string;
            };
            res: {
                /**
                 * schemas of all datatables
                 */
                200: Array<DataTableSchema>;
            };
        };
    };
    '/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/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;
                };
            };
        };
    };
    '/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;
                    sqs_used: boolean;
                    email_used: boolean;
                    nextcloud_used: boolean;
                    google_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;
            };
        };
    };
    '/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/global/{key}': {
        get: {
            req: {
                key: string;
            };
            res: {
                /**
                 * status
                 */
                200: unknown;
            };
        };
        post: {
            req: {
                key: string;
                /**
                 * value set
                 */
                requestBody: {
                    value?: unknown;
                };
            };
            res: {
                /**
                 * status
                 */
                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/test_object_storage_config': {
        post: {
            req: {
                /**
                 * test object storage config
                 */
                requestBody: {
                    [key: string]: unknown;
                };
            };
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/send_stats': {
        post: {
            res: {
                /**
                 * status
                 */
                200: string;
            };
        };
    };
    '/settings/get_stats': {
        get: {
            res: {
                /**
                 * base64-encoded encrypted telemetry blob
                 */
                200: 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;
            };
        };
    };
    '/settings/list_global': {
        get: {
            res: {
                /**
                 * list of settings
                 */
                200: Array<GlobalSetting>;
            };
        };
    };
    '/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;
            };
        };
    };
    '/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;
                /**
                 * 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_callback': {
        post: {
            req: {
                /**
                 * code endpoint
                 */
                requestBody: {
                    code: string;
                    state: string;
                };
                workspace: string;
            };
            res: {
                /**
                 * slack token
                 */
                200: string;
            };
        };
    };
    '/oauth/connect_slack_callback': {
        post: {
            req: {
                /**
                 * code endpoint
                 */
                requestBody: {
                    code: string;
                    state: string;
                };
            };
            res: {
                /**
                 * success message
                 */
                200: string;
            };
        };
    };
    '/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;
                };
                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;
                };
            };
        };
    };
    '/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;
                /**
                 * 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}/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;
                /**
                 * 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;
                /**
                 * 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;
                };
                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;
                    };
                    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;
                };
                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;
                    };
                    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;
                    };
                    id?: number;
                    force_viewer_static_fields?: {
                        [key: string]: unknown;
                    };
                    force_viewer_one_of_fields?: {
                        [key: string]: unknown;
                    };
                    force_viewer_allow_user_resources?: Array<(string)>;
                    /**
                     * 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 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/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}/drafts/create': {
        post: {
            req: {
                requestBody: {
                    path: string;
                    typ: 'flow' | 'script' | 'app';
                    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: {
                    /**
                     * step id to restart the flow from
                     */
                    step_id: string;
                    /**
                     * for branchall or loop, 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;
                };
                /**
                 * 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/workflow_as_code/{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/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: {
                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: {
                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_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;
                    workflow_as_code_status?: WorkflowStatus;
                };
            };
        };
    };
    '/w/{workspace}/jobs_u/getupdate_sse/{id}': {
        get: {
            req: {
                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;
                cancelButtonText?: string;
                channelName: string;
                defaultArgsJson?: string;
                dynamicEnumsJson?: string;
                flowStepId: string;
                id: string;
                message?: string;
                resumeButtonText?: string;
                teamName: string;
                workspace: string;
            };
            res: {
                /**
                 * Interactive slack approval message sent successfully
                 */
                200: unknown;
            };
        };
    };
    '/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}/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: {
                /**
                 * id to fetch only the messages after that id
                 */
                afterId?: string;
                /**
                 * 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}/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;
                /**
                 * 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;
                };
            };
            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;
                };
                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;
                /**
                 * 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;
                /**
                 * 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;
                };
                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;
                /**
                 * 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;
                };
                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;
                /**
                 * 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;
                };
                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;
                /**
                 * 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;
                };
                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;
                /**
                 * 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;
                };
                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;
                /**
                 * 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>;
            };
        };
    };
    '/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;
                /**
                 * 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;
                };
                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;
                /**
                 * 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;
                };
                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}/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;
                /**
                 * 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;
                };
                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;
                /**
                 * 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;
                };
                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: InstanceGroup;
            };
        };
    };
    '/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;
                };
            };
            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;
                };
                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;
                };
                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/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)>;
            };
        };
    };
    '/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' | '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' | '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' | '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';
                };
                workspace: string;
            };
            res: {
                /**
                 * star item
                 */
                200: unknown;
            };
        };
    };
    '/w/{workspace}/favorites/unstar': {
        post: {
            req: {
                requestBody?: {
                    path?: string;
                    favorite_kind?: 'flow' | 'app' | 'script' | 'raw_app' | 'asset';
                };
                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;
                    windmill_large_files: Array<WindmillLargeFile>;
                    restricted_access?: boolean;
                };
            };
        };
    };
    '/w/{workspace}/job_helpers/load_file_metadata': {
        get: {
            req: {
                fileKey: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * FileMetadata
                 */
                200: WindmillFileMetadata;
            };
        };
    };
    '/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: WindmillFilePreview;
            };
        };
    };
    '/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;
                    windmill_large_files: Array<WindmillLargeFile>;
                    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: WindmillFilePreview;
            };
        };
    };
    '/w/{workspace}/job_helpers/load_git_repo_file_metadata': {
        get: {
            req: {
                fileKey: string;
                storage?: string;
                workspace: string;
            };
            res: {
                /**
                 * FileMetadata
                 */
                200: WindmillFileMetadata;
            };
        };
    };
    '/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;
                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;
                    };
                };
            };
        };
    };
    '/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-separated list of OAuth scopes to request
                 */
                scopes?: string;
            };
            res: {
                /**
                 * Redirect to OAuth provider authorization URL
                 */
                302: unknown;
            };
        };
    };
    '/mcp/oauth/callback': {
        get: {
            req: {
                /**
                 * OAuth authorization code
                 */
                code: string;
                /**
                 * CSRF state token
                 */
                state: string;
            };
            res: {
                /**
                 * HTML page with JavaScript that posts tokens to opener window and closes
                 */
                200: string;
            };
        };
    };
};