/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/health": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Check server health status
         * @description Returns health information about the Dagu server
         */
        get: operations["getHealthStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/openapi.json": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get the OpenAPI document
         * @description Returns the normalized OpenAPI document served by this Dagu instance
         */
        get: operations["getOpenapiJson"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/setup": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create initial admin account
         * @description Creates the first admin user during initial setup. Only available when no users exist. Returns a JWT token for immediate login.
         */
        post: operations["setup"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/login": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Authenticate user and obtain JWT token
         * @description Authenticates a user with username and password, returns a JWT token on success
         */
        post: operations["login"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/me": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get current authenticated user
         * @description Returns information about the currently authenticated user
         */
        get: operations["getCurrentUser"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/auth/change-password": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Change current user's password
         * @description Allows the authenticated user to change their own password
         */
        post: operations["changePassword"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/users": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all users
         * @description Returns a list of all users. Requires admin role.
         */
        get: operations["listUsers"];
        put?: never;
        /**
         * Create a new user
         * @description Creates a new user account. Requires admin role.
         */
        post: operations["createUser"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/users/{userId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get user by ID
         * @description Returns a specific user by their ID. Requires admin role.
         */
        get: operations["getUser"];
        put?: never;
        post?: never;
        /**
         * Delete user
         * @description Deletes a user account. Requires admin role. Cannot delete yourself.
         */
        delete: operations["deleteUser"];
        options?: never;
        head?: never;
        /**
         * Update user
         * @description Updates a user's information. Requires admin role.
         */
        patch: operations["updateUser"];
        trace?: never;
    };
    "/users/{userId}/reset-password": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reset user's password
         * @description Resets a user's password to a new value. Requires admin role.
         */
        post: operations["resetUserPassword"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api-keys": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all API keys
         * @description Returns all API keys. Requires admin role.
         */
        get: operations["listAPIKeys"];
        put?: never;
        /**
         * Create API key
         * @description Full key returned only in this response
         */
        post: operations["createAPIKey"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/api-keys/{keyId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get API key
         * @description Returns API key by ID. Requires admin role.
         */
        get: operations["getAPIKey"];
        put?: never;
        post?: never;
        /**
         * Delete API key
         * @description Revokes an API key. Requires admin role.
         */
        delete: operations["deleteAPIKey"];
        options?: never;
        head?: never;
        /**
         * Update API key
         * @description Updates API key info. Requires admin role.
         */
        patch: operations["updateAPIKey"];
        trace?: never;
    };
    "/workers": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List distributed workers
         * @description Retrieves information about distributed workers connected to the coordinator. Developer, manager, or admin only.
         */
        get: operations["getWorkers"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all available DAGs
         * @description Retrieves DAG definitions with optional filtering by name and labels
         */
        get: operations["listDAGs"];
        put?: never;
        /**
         * Create a new DAG definition
         * @description Creates a new empty DAG file with the specified name
         */
        post: operations["createNewDAG"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/validate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Validate a DAG specification
         * @description Validates a DAG YAML specification without persisting any changes.
         *
         *     Returns a list of validation errors. When the spec can be partially parsed,
         *     the response may also include parsed DAG details built with error-tolerant loading.
         *
         */
        post: operations["validateDAGSpec"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve comprehensive DAG information
         * @description Fetches detailed information about a specific DAG definition
         */
        get: operations["getDAGDetails"];
        put?: never;
        post?: never;
        /**
         * Delete an existing DAG
         * @description Permanently removes a DAG definition from the system
         */
        delete: operations["deleteDAG"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/start": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create and execute a DAG-run from DAG
         * @description Creates a DAG-run from the DAG definition and starts its execution with optional parameters
         */
        post: operations["executeDAG"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/start-sync": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Execute DAG synchronously and wait for completion
         * @description Creates a DAG-run from the DAG definition, starts its execution, waits for it to complete (or timeout), and returns the full execution details including node statuses.
         *
         *     **Important behaviors:**
         *     - If the timeout is exceeded, the DAG run continues executing in the background. The 408 response includes the `dagRunId` so clients can monitor or cancel the run.
         *     - If the DAG reaches a 'waiting' status (human-in-the-loop approval needed), the endpoint returns immediately with 200 and the current status.
         *
         */
        post: operations["executeDAGSync"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/enqueue": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Enqueue a DAG-run from DAG
         * @description Creates a DAG-run from the DAG definition and adds it to the queue for execution
         */
        post: operations["enqueueDAGDAGRun"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/dag-runs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve execution history of a DAG
         * @description Fetches history of DAG-runs created from this DAG definition
         */
        get: operations["getDAGDAGRunHistory"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/dag-runs/{dagRunId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get detailed status of a specific DAG-run
         * @description Retrieves status information about a particular DAG-run created from this DAG
         */
        get: operations["getDAGDAGRunDetails"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/spec": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve DAG specification
         * @description Fetches the YAML specification of a DAG definition
         */
        get: operations["getDAGSpec"];
        /**
         * Update DAG spec
         * @description Modifies the YAML specification of a DAG definition
         */
        put: operations["updateDAGSpec"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/suspend": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Toggle DAG suspension state
         * @description Controls whether the scheduler should create DAG-runs from this DAG according to its defined cron schedule
         */
        post: operations["updateDAGSuspensionState"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/rename": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Change DAG file ID
         * @description Changes the file ID of the DAG definition
         */
        post: operations["renameDAG"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/stop-all": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stop all running instances of a DAG
         * @description Terminates all currently running DAG-runs for the specified DAG
         */
        post: operations["stopAllDAGRuns"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/search": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search DAGs
         * @description Performs a full-text search across all DAG definitions
         */
        get: operations["searchDAGs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/dags": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search DAGs
         * @description Returns cursor-based, lightweight DAG search results for the global search page.
         */
        get: operations["searchDAGFeed"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/docs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search documents
         * @description Returns cursor-based, lightweight document search results for the global search page.
         */
        get: operations["searchDocFeed"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/dags/{fileName}/matches": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search DAG match snippets
         * @description Returns cursor-based snippets for one matching DAG definition.
         */
        get: operations["searchDagMatches"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/search/docs/matches": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search document match snippets
         * @description Returns cursor-based snippets for one matching document.
         */
        get: operations["searchDocMatches"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/labels": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all available DAG labels
         * @description Retrieves all unique labels used across DAG definitions
         */
        get: operations["getAllDAGLabels"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/tags": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all available DAG tags
         * @deprecated
         * @description Deprecated alias for /dags/labels. Retrieves all unique labels used across DAG definitions.
         */
        get: operations["getAllDAGTags"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all DAG-runs
         * @description Retrieves a list of all DAG-runs with optional filtering by name and status
         */
        get: operations["listDAGRuns"];
        put?: never;
        /**
         * Create and execute a DAG-run from inline spec
         * @description Creates a DAG-run directly from a provided DAG specification (YAML) and starts execution.
         *
         *     This endpoint does not require a pre-existing DAG file; the supplied `spec` is parsed and validated
         *     similarly to `/dags/validate`, and the run is executed immediately if valid.
         *
         */
        post: operations["executeDAGRunFromSpec"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/enqueue": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Enqueue a DAG-run from inline spec
         * @description Creates a DAG-run directly from a provided DAG specification (YAML) and enqueues it for execution.
         *
         *     This endpoint does not require a pre-existing DAG file; the supplied `spec` is parsed and validated
         *     similarly to `/dags/validate`, and the run is persisted to the queue if valid.
         *
         */
        post: operations["enqueueDAGRunFromSpec"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all DAG-runs with a specific name
         * @description Retrieves a list of all DAG-runs with optional filtering by name and status
         */
        get: operations["listDAGRunsByName"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve detailed status of a DAG-run
         * @description Fetches detailed status information about a specific DAG-run. Use 'latest' as the dagRunId to retrieve the most recent DAG-run for the specified DAG name.
         */
        get: operations["getDAGRunDetails"];
        put?: never;
        post?: never;
        /**
         * Delete a DAG-run
         * @description Permanently removes a DAG-run record and its associated run data. Developer, manager, or admin only.
         */
        delete: operations["deleteDAGRun"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/spec": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve DAG specification for a DAG-run
         * @description Fetches the YAML specification of the DAG definition associated with this DAG-run
         */
        get: operations["getDAGRunSpec"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/reschedule": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reschedule DAG-run with a new run ID
         * @description Launch a fresh DAG-run from a historic execution while reusing its stored parameters.
         */
        post: operations["rescheduleDAGRun"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/edit-retry/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Preview edited DAG-run retry
         * @description Validates an edited DAG definition against a previous DAG-run and returns the default step skip selection.
         */
        post: operations["previewEditRetryDAGRun"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/edit-retry": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Run edited DAG retry
         * @description Creates a new DAG-run from an edited DAG definition while preserving outputs from selected skipped steps.
         */
        post: operations["editRetryDAGRun"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get sub DAG runs with timing info
         * @description Retrieves timing and status information for all sub DAG runs (including repeated executions) of a specific step. When parentSubDAGRunId is provided, returns sub-runs of that specific sub DAG run (for multi-level nested DAGs).
         */
        get: operations["getSubDAGRuns"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/dequeue": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Dequeue a queued DAG-run
         * @description Dequeue a DAG-run execution that is currently queued
         */
        get: operations["dequeueDAGRun"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/log": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve full execution log of a DAG-run
         * @description Fetches the execution log for a DAG-run
         */
        get: operations["getDAGRunLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/log/download": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Download full execution log of a DAG-run
         * @description Downloads the entire execution log file for a DAG-run
         */
        get: operations["downloadDAGRunLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/artifacts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List artifacts for a DAG-run
         * @description Returns the artifact file tree for a DAG-run
         */
        get: operations["getDAGRunArtifacts"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/artifacts/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Preview an artifact for a DAG-run
         * @description Returns preview metadata and text content for a single artifact file
         */
        get: operations["getDAGRunArtifactPreview"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/artifacts/download": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Download an artifact for a DAG-run
         * @description Downloads a single artifact file from a DAG-run
         */
        get: operations["downloadDAGRunArtifact"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/outputs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve collected outputs from a DAG-run
         * @description Fetches the outputs.json file containing all step outputs collected during the DAG-run execution. Returns the outputs as a JSON object where keys are the output names (converted from UPPER_CASE to camelCase by default, or custom key if specified) and values are the captured output strings.
         */
        get: operations["getDAGRunOutputs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/retry": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Retry DAG-run execution
         * @description Creates a new DAG-run based on a previous execution
         */
        post: operations["retryDAGRun"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/stop": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Terminate or cancel a DAG-run
         * @description Forcefully stops a running DAG-run, or cancels a failed root DAG-run that is still pending DAG-level automatic retry.
         */
        post: operations["terminateDAGRun"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/steps/{stepName}/log": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve log for a specific step in a DAG-run
         * @description Fetches the log for an individual step in a DAG-run
         */
        get: operations["getDAGRunStepLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/steps/{stepName}/log/download": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Download log for a specific step in a DAG-run
         * @description Downloads the entire log file for an individual step in a DAG-run
         */
        get: operations["downloadDAGRunStepLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/steps/{stepName}/messages": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve chat messages for a step
         * @description Fetches the LLM chat message history for a chat step. Returns empty array for non-chat steps.
         */
        get: operations["getDAGRunStepMessages"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/steps/{stepName}/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /**
         * Manually update a step's execution status
         * @description Changes the status of a specific step within a DAG-run
         */
        patch: operations["updateDAGRunStepStatus"];
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/steps/{stepName}/approve": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Approve a waiting step
         * @description Approves a step that is in Waiting status, optionally providing input parameters that will be available as environment variables in subsequent steps
         */
        post: operations["approveDAGRunStep"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/steps/{stepName}/reject": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reject a waiting step
         * @description Rejects a step that is in Waiting status, optionally providing a reason for rejection
         */
        post: operations["rejectDAGRunStep"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/steps/{stepName}/push-back": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Push back a waiting step for re-execution with feedback
         * @description Pushes back a step that is in Waiting status, providing input parameters that will be injected as environment variables when the step re-executes. The step must have an approval configuration.
         */
        post: operations["pushBackDAGRunStep"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve detailed status of a sub DAG-run
         * @description Fetches detailed status information about a specific sub DAG-run
         */
        get: operations["getSubDAGRunDetails"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/spec": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get Sub-DAG Run Specification
         * @description Returns the YAML specification used for a specific sub-DAG run
         */
        get: operations["getSubDAGRunSpec"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/log": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve log for a specific sub DAG-run
         * @description Fetches the log for an individual sub DAG-run
         */
        get: operations["getSubDAGRunLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/log/download": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Download log for a specific sub DAG-run
         * @description Downloads the entire log file for an individual sub DAG-run
         */
        get: operations["downloadSubDAGRunLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/artifacts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List artifacts for a sub DAG-run
         * @description Returns the artifact file tree for a specific sub DAG-run
         */
        get: operations["getSubDAGRunArtifacts"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/artifacts/preview": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Preview an artifact for a sub DAG-run
         * @description Returns preview metadata and text content for a single sub DAG-run artifact file
         */
        get: operations["getSubDAGRunArtifactPreview"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/artifacts/download": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Download an artifact for a sub DAG-run
         * @description Downloads a single artifact file from a sub DAG-run
         */
        get: operations["downloadSubDAGRunArtifact"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/steps/{stepName}/log": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve log for a specific step in a sub DAG-run
         * @description Fetches the log for an individual step in a sub DAG-run
         */
        get: operations["getSubDAGRunStepLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/steps/{stepName}/log/download": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Download log for a specific step in a sub DAG-run
         * @description Downloads the entire log file for an individual step in a sub DAG-run
         */
        get: operations["downloadSubDAGRunStepLog"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/steps/{stepName}/messages": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Retrieve chat messages for a step in a sub DAG-run
         * @description Fetches the LLM chat message history for a chat step in a sub DAG-run. Returns empty array for non-chat steps.
         */
        get: operations["getSubDAGRunStepMessages"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/steps/{stepName}/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /**
         * Manually update a step's execution status in a sub DAG-run
         * @description Changes the status of a specific step within a sub DAG-run
         */
        patch: operations["updateSubDAGRunStepStatus"];
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/steps/{stepName}/approve": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Approve a waiting step in a sub DAG-run
         * @description Approves a step that is in Waiting status within a sub DAG-run, optionally providing input parameters that will be available as environment variables in subsequent steps
         */
        post: operations["approveSubDAGRunStep"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/steps/{stepName}/reject": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reject a waiting step in a sub DAG-run
         * @description Rejects a step that is in Waiting status within a sub DAG-run, optionally providing a reason for rejection
         */
        post: operations["rejectSubDAGRunStep"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dag-runs/{name}/{dagRunId}/sub-dag-runs/{subDAGRunId}/steps/{stepName}/push-back": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Push back a waiting step in a sub DAG-run for re-execution with feedback
         * @description Pushes back a step that is in Waiting status within a sub DAG-run, providing input parameters that will be injected as environment variables when the step re-executes. The step must have an approval configuration.
         */
        post: operations["pushBackSubDAGRunStep"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/queues": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all execution queues with summary statistics
         * @description Returns queue list with running and queued counts. Use /queues/{name} for queue details and /queues/{name}/items for queued backlog browsing.
         */
        get: operations["listQueues"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/queues/{name}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get summary information for a specific queue
         * @description Returns queue metadata, running items, and queued counts for the specified queue.
         */
        get: operations["getQueue"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/queues/{name}/items": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get queued items for a specific queue
         * @description Returns one forward-only page of queued DAG-runs for the specified queue, ordered from the queue head toward the tail. The opaque cursor resumes after the last scanned queue entry.
         */
        get: operations["listQueueItems"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/services/resources/history": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get resource usage history
         * @description Returns historical data for system resources. Developer, manager, or admin only.
         */
        get: operations["getResourceHistory"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/services/scheduler": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get scheduler service status
         * @description Returns status information about all registered scheduler instances. Developer, manager, or admin only.
         */
        get: operations["getSchedulerStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/services/coordinator": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get coordinator service status
         * @description Returns status information about all registered coordinator instances. Developer, manager, or admin only.
         */
        get: operations["getCoordinatorStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/services/tunnel": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get tunnel service status
         * @description Returns status information about the tunnel service (Tailscale). Developer, manager, or admin only.
         */
        get: operations["getTunnelStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/metrics": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get Prometheus metrics
         * @description Returns Prometheus-compatible metrics for monitoring Dagu operations
         */
        get: operations["getMetrics"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/webhooks/{fileName}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Trigger DAG execution via webhook
         * @description Triggers a DAG execution via webhook. The DAG must have a webhook configured
         *     and enabled. Authentication depends on the webhook auth mode:
         *     bearer token only, bearer token plus HMAC, or HMAC only.
         *
         *     The request body is passed to the DAG as the WEBHOOK_PAYLOAD environment
         *     variable. If the DAG configures `webhook.forward_headers`, selected
         *     request headers are passed as the WEBHOOK_HEADERS environment variable.
         *     For safety, the `Authorization` header is never forwarded.
         *     The DAG run is enqueued and the endpoint returns immediately with the
         *     dag-run ID.
         *
         */
        post: operations["triggerWebhook"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/webhooks": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all webhooks
         * @description Returns a list of all webhooks across all DAGs. Developer, manager, or admin only.
         */
        get: operations["listWebhooks"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/notification-settings": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get notification settings
         * @description Returns workspace-level notification settings such as email delivery transport. Developer, manager, or admin only.
         */
        get: operations["getNotificationSettings"];
        /**
         * Update notification settings
         * @description Updates workspace-level notification settings. SMTP passwords are accepted
         *     in the request but are never returned. Omit password on updates to preserve
         *     the existing password, or set clearPassword to remove it. Developer,
         *     manager, or admin only.
         *
         */
        put: operations["updateNotificationSettings"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/notification-routes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List notification routes
         * @description Returns global and workspace notification channel routes. Notification channels and rules require an active Dagu license or trial. Developer, manager, or admin only.
         */
        get: operations["listNotificationRoutes"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/notification-routes/global": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get global notification routes
         * @description Returns global default notification channel routes. Default DAGs use global routes; named workspaces can inherit or opt out. Developer, manager, or admin only.
         */
        get: operations["getGlobalNotificationRoutes"];
        /**
         * Update global notification routes
         * @description Replaces global default notification channel routes. Route channel IDs must reference notification channels. Developer, manager, or admin only.
         */
        put: operations["updateGlobalNotificationRoutes"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/notification-routes/workspaces/{workspaceName}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get workspace notification routes
         * @description Returns notification channel routes for one named workspace. Workspace routes can inherit global defaults. Developer, manager, or admin only.
         */
        get: operations["getWorkspaceNotificationRoutes"];
        /**
         * Update workspace notification routes
         * @description Replaces notification channel routes for one named workspace. Route channel IDs must reference notification channels. Developer, manager, or admin only.
         */
        put: operations["updateWorkspaceNotificationRoutes"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/notification-channels": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List notification channels
         * @description Returns notification channels. Channels are delivery endpoints; routing is configured separately. Developer, manager, or admin only.
         */
        get: operations["listNotificationChannels"];
        put?: never;
        /**
         * Create notification channel
         * @description Creates a notification channel. Secret values are accepted
         *     in the request but are never returned. Developer, manager, or admin only.
         *
         */
        post: operations["createNotificationChannel"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/notification-channels/{channelId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get notification channel
         * @description Returns one notification channel. Developer, manager, or admin only.
         */
        get: operations["getNotificationChannel"];
        /**
         * Update notification channel
         * @description Replaces a notification channel. Existing secret values
         *     are preserved when omitted. Developer, manager, or admin only.
         *
         */
        put: operations["updateNotificationChannel"];
        post?: never;
        /**
         * Delete notification channel
         * @description Deletes a notification channel. Channels referenced by DAG notification settings or notification routes cannot be deleted.
         */
        delete: operations["deleteNotificationChannel"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/incident-providers": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List incident providers
         * @description Returns configured incident providers such as PagerDuty and SolarWinds Incident Response. Incident management requires an active Dagu license or trial. Developer, manager, or admin only.
         */
        get: operations["listIncidentProviders"];
        put?: never;
        /**
         * Create incident provider
         * @description Creates an incident provider. Secret values are accepted in the request but are never returned. Developer, manager, or admin only.
         */
        post: operations["createIncidentProvider"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/incident-providers/{providerId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get incident provider
         * @description Returns one incident provider. Developer, manager, or admin only.
         */
        get: operations["getIncidentProvider"];
        /**
         * Update incident provider
         * @description Replaces an incident provider. Existing secret values are preserved when omitted. Developer, manager, or admin only.
         */
        put: operations["updateIncidentProvider"];
        post?: never;
        /**
         * Delete incident provider
         * @description Deletes an incident provider. Providers referenced by incident routing cannot be deleted.
         */
        delete: operations["deleteIncidentProvider"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/incident-providers/{providerId}/test": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send a test incident
         * @description Sends a test trigger and resolve event to one incident provider. Developer, manager, or admin only.
         */
        post: operations["testIncidentProvider"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/incident-policies": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List incident routing
         * @description Returns global, workspace, and DAG incident routing. Developer, manager, or admin only.
         */
        get: operations["listIncidentPolicies"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/incident-policies/global": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get global incident routing
         * @description Returns global incident routing. Global routing is used unless a workspace or DAG override is configured. Developer, manager, or admin only.
         */
        get: operations["getGlobalIncidentPolicies"];
        /**
         * Update global incident routing
         * @description Replaces global incident routing. Route provider IDs must reference incident providers. Developer, manager, or admin only.
         */
        put: operations["updateGlobalIncidentPolicies"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/incident-policies/workspaces/{workspaceName}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get workspace incident routing
         * @description Returns incident routing for one named workspace. Workspace routing can inherit global routing. Developer, manager, or admin only.
         */
        get: operations["getWorkspaceIncidentPolicies"];
        /**
         * Update workspace incident routing
         * @description Replaces incident routing for one named workspace. Route provider IDs must reference incident providers. Developer, manager, or admin only.
         */
        put: operations["updateWorkspaceIncidentPolicies"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/webhook": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get webhook for DAG
         * @description Returns the webhook configuration for a specific DAG, if one exists.
         */
        get: operations["getDAGWebhook"];
        put?: never;
        /**
         * Create webhook for DAG
         * @description Creates a new webhook for the specified DAG. Returns the full webhook token,
         *     which is only shown once. Store it securely.
         *     Developer, manager, or admin only.
         *
         */
        post: operations["createDAGWebhook"];
        /**
         * Delete webhook for DAG
         * @description Removes the webhook configuration for the specified DAG. Developer, manager, or admin only.
         */
        delete: operations["deleteDAGWebhook"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/webhook/regenerate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Regenerate webhook token
         * @description Generates a new token for the existing webhook. The old token becomes
         *     invalid immediately. Returns the new token, which is only shown once.
         *     Developer, manager, or admin only.
         *
         */
        post: operations["regenerateDAGWebhookToken"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/webhook/toggle": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Toggle webhook enabled state
         * @description Enables or disables the webhook without changing the token. Developer, manager, or admin only.
         */
        post: operations["toggleDAGWebhook"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/webhook/hmac/enable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Enable webhook HMAC
         * @description Enables HMAC authentication for the existing webhook and returns the generated
         *     HMAC secret exactly once. If enforcementMode is omitted, it defaults to
         *     strict. Developer, manager, or admin only.
         *
         */
        post: operations["enableDAGWebhookHMAC"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/webhook/hmac/configure": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Configure webhook HMAC
         * @description Updates the webhook HMAC auth mode or enforcement mode without rotating
         *     the secret. If enforcementMode is omitted, the current enforcement mode
         *     is preserved for token_and_hmac, while hmac_only always uses strict.
         *     Developer, manager, or admin only.
         *
         */
        post: operations["configureDAGWebhookHMAC"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/webhook/hmac/regenerate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Regenerate webhook HMAC secret
         * @description Generates a new HMAC secret for the existing webhook. The old secret becomes
         *     invalid immediately. Returns the new secret exactly once.
         *     Developer, manager, or admin only.
         *
         */
        post: operations["regenerateDAGWebhookHMACSecret"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/webhook/hmac/disable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Disable webhook HMAC
         * @description Disables HMAC authentication and returns the webhook to token-only mode. Developer, manager, or admin only.
         */
        post: operations["disableDAGWebhookHMAC"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/notifications": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get DAG notification settings
         * @description Returns server-side notification settings for a specific DAG. Developer, manager, or admin only.
         */
        get: operations["getDAGNotifications"];
        /**
         * Update DAG notification settings
         * @description Creates or replaces server-side notification settings for a DAG.
         *     Secret values are accepted in the request but are never returned.
         *     Existing secret values are preserved when omitted for an existing target.
         *     Developer, manager, or admin only.
         *
         */
        put: operations["updateDAGNotifications"];
        post?: never;
        /**
         * Delete DAG notification settings
         * @description Removes all server-side notification settings for the specified DAG. Developer, manager, or admin only.
         */
        delete: operations["deleteDAGNotifications"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/notifications/test": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send a test DAG notification
         * @description Sends a test notification to one target or every enabled target for a DAG. Developer, manager, or admin only.
         */
        post: operations["testDAGNotifications"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/dags/{fileName}/incidents": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get DAG incident routing
         * @description Returns DAG-level incident routing override settings. Missing settings mean this DAG inherits workspace or global routing. Developer, manager, or admin only.
         */
        get: operations["getDAGIncidents"];
        /**
         * Update DAG incident routing
         * @description Creates or replaces DAG-level incident routing override settings. Route provider IDs must reference incident providers. Developer, manager, or admin only.
         */
        put: operations["updateDAGIncidents"];
        post?: never;
        /**
         * Delete DAG incident routing
         * @description Removes DAG-level incident routing override settings so the DAG inherits workspace or global routing. Developer, manager, or admin only.
         */
        delete: operations["deleteDAGIncidents"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/audit": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List audit log entries
         * @description Returns audit log entries matching the filter criteria. Manager or admin only.
         */
        get: operations["listAuditLogs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/event-logs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List centralized event log entries
         * @description Returns centralized event log entries matching the filter criteria. Manager or admin only.
         */
        get: operations["listEventLogs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get Git sync status
         * @description Returns the overall Git sync status including status of all DAGs
         */
        get: operations["getSyncStatus"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/pull": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Pull changes from remote repository
         * @description Fetches and syncs changes from the remote Git repository
         */
        post: operations["syncPull"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/publish-all": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Publish selected DAGs
         * @description Commits and pushes the specified item IDs. If itemIds is omitted, publishes all modified or untracked items.
         */
        post: operations["syncPublishAll"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/test-connection": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Test connection to remote repository
         * @description Tests authentication and connectivity to the configured Git repository
         */
        post: operations["syncTestConnection"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get Git sync configuration
         * @description Returns the current Git sync configuration
         */
        get: operations["getSyncConfig"];
        /**
         * Update Git sync configuration
         * @description Updates the Git sync configuration
         */
        put: operations["updateSyncConfig"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/items/{itemId}/diff": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get diff for a sync item
         * @description Returns the diff between local and remote versions of a sync item
         */
        get: operations["getSyncItemDiff"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/items/{itemId}/publish": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Publish a single sync item
         * @description Commits and pushes a single sync item to the remote repository
         */
        post: operations["publishSyncItem"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/items/{itemId}/discard": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Discard local changes for a sync item
         * @description Discards local changes and reverts to the version in the remote repository
         */
        post: operations["discardSyncItemChanges"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/items/{itemId}/forget": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Forget a sync item
         * @description Removes the state entry for a missing, untracked, or conflict sync item. Synced and modified items are rejected.
         */
        post: operations["forgetSyncItem"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/items/{itemId}/delete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete a sync item
         * @description Removes an item from remote repository (git rm + commit + push), local disk, and sync state
         */
        post: operations["deleteSyncItem"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/items/{itemId}/move": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Move a sync item
         * @description Atomically renames an item across local filesystem, remote repository, and sync state
         */
        post: operations["moveSyncItem"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/delete-missing": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete all missing sync items
         * @description Removes all missing items from remote repository, local disk, and sync state
         */
        post: operations["syncDeleteMissing"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/delete-batch": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete selected sync items
         * @description Removes the specified items from remote repository, local disk, and sync state in a single commit.
         */
        post: operations["syncDeleteBatch"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/cleanup": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Cleanup missing sync items
         * @description Removes all missing entries from sync state
         */
        post: operations["syncCleanup"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/base-config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get base configuration
         * @description Returns the base DAG configuration YAML. Requires developer role or above.
         */
        get: operations["getBaseConfig"];
        /**
         * Update base configuration
         * @description Updates the base DAG configuration YAML. Validates before saving. Requires developer role or above.
         */
        put: operations["updateBaseConfig"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/workspaces/{workspaceName}/base-config": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get workspace base configuration
         * @description Returns the workspace-scoped base DAG configuration YAML. Requires access to the workspace.
         */
        get: operations["getWorkspaceBaseConfig"];
        /**
         * Update workspace base configuration
         * @description Updates the workspace-scoped base DAG configuration YAML. Validates before saving. Requires write access to the workspace.
         */
        put: operations["updateWorkspaceBaseConfig"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get agent configuration
         * @description Returns the current AI agent configuration. Requires admin role.
         */
        get: operations["getAgentConfig"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        /**
         * Update agent configuration
         * @description Updates the AI agent configuration. Requires admin role.
         */
        patch: operations["updateAgentConfig"];
        trace?: never;
    };
    "/settings/agent/models": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List agent models
         * @description Returns all configured AI agent models. Requires admin role.
         */
        get: operations["listAgentModels"];
        put?: never;
        /**
         * Create agent model
         * @description Creates a new AI agent model configuration. Requires admin role.
         */
        post: operations["createAgentModel"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/auth/providers": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List agent auth providers
         * @description Returns subscription-backed agent auth provider status for the selected node. Requires admin role.
         */
        get: operations["listAgentAuthProviders"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/auth/providers/{providerId}/login": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Start agent auth provider login
         * @description Starts a manual OAuth login flow for the selected provider. Requires admin role.
         */
        post: operations["startAgentAuthProviderLogin"];
        /**
         * Disconnect agent auth provider login
         * @description Removes the stored OAuth credential for the selected provider. Requires admin role.
         */
        delete: operations["disconnectAgentAuthProviderLogin"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/auth/providers/{providerId}/login/complete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Complete agent auth provider login
         * @description Completes a manual OAuth login flow using the pasted redirect URL or authorization code. Requires admin role.
         */
        post: operations["completeAgentAuthProviderLogin"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/models/{modelId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        post?: never;
        /**
         * Delete agent model
         * @description Deletes an AI agent model configuration. Requires admin role.
         */
        delete: operations["deleteAgentModel"];
        options?: never;
        head?: never;
        /**
         * Update agent model
         * @description Updates an existing AI agent model configuration. Requires admin role.
         */
        patch: operations["updateAgentModel"];
        trace?: never;
    };
    "/settings/agent/default-model": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        /**
         * Set default agent model
         * @description Sets the default model for the AI agent. Requires admin role.
         */
        put: operations["setDefaultAgentModel"];
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/memory": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get agent memory
         * @description Returns global memory content and list of DAGs with memory. Requires admin role.
         */
        get: operations["getAgentMemory"];
        /**
         * Update global agent memory
         * @description Updates the global MEMORY.md content. Requires admin role.
         */
        put: operations["updateAgentMemory"];
        post?: never;
        /**
         * Clear global agent memory
         * @description Deletes the global MEMORY.md file. Requires admin role.
         */
        delete: operations["deleteAgentMemory"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/memory/dags/{dagName}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get DAG-specific agent memory
         * @description Returns memory content for a specific DAG. Requires admin role.
         */
        get: operations["getAgentDAGMemory"];
        /**
         * Update DAG-specific agent memory
         * @description Updates the memory content for a specific DAG. Requires admin role.
         */
        put: operations["updateAgentDAGMemory"];
        post?: never;
        /**
         * Clear DAG-specific agent memory
         * @description Deletes the memory file for a specific DAG. Requires admin role.
         */
        delete: operations["deleteAgentDAGMemory"];
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/model-presets": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List model presets
         * @description Returns hardcoded model presets with metadata. Requires admin role.
         */
        get: operations["listModelPresets"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/tools": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List agent tools
         * @description Returns metadata for all registered agent tools.
         */
        get: operations["listAgentTools"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/souls": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List agent souls
         * @description Returns all configured agent souls (personalities). Requires admin role.
         */
        get: operations["listAgentSouls"];
        put?: never;
        /**
         * Create agent soul
         * @description Creates a new agent soul (personality). Requires admin role.
         */
        post: operations["createAgentSoul"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/settings/agent/souls/{soulId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get agent soul
         * @description Returns a single agent soul by ID. Requires admin role.
         */
        get: operations["getAgentSoul"];
        put?: never;
        post?: never;
        /**
         * Delete agent soul
         * @description Deletes an agent soul. Requires admin role.
         */
        delete: operations["deleteAgentSoul"];
        options?: never;
        head?: never;
        /**
         * Update agent soul
         * @description Updates an existing agent soul. Requires admin role.
         */
        patch: operations["updateAgentSoul"];
        trace?: never;
    };
    "/agent/sessions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List agent sessions
         * @description Lists sessions for the current user. `listAgentSessions` uses `AgentSessionPaginationMode=cursor` or an `AgentSessionCursor` value to return cursor pages and `nextCursor`; cursor mode rejects `Page` because mixed cursor/page requests are ambiguous, while `PerPage` still controls page size. Without cursor mode it uses `Page` and `PerPage` offset pagination. `RemoteNode` selects the target node for either pagination mode. Malformed or invalid cursor values return 400.
         */
        get: operations["listAgentSessions"];
        put?: never;
        /**
         * Create agent session
         * @description Creates a new agent session and sends the first message.
         */
        post: operations["createAgentSession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agent/sessions/{sessionId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get agent session
         * @description Returns session details including messages and current state.
         */
        get: operations["getAgentSession"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agent/sessions/{sessionId}/chat": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Send message to agent session
         * @description Sends a message to an existing agent session.
         */
        post: operations["chatAgentSession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agent/sessions/{sessionId}/cancel": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Cancel agent session
         * @description Cancels processing in an active agent session.
         */
        post: operations["cancelAgentSession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/agent/sessions/{sessionId}/respond": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Respond to agent prompt
         * @description Submits user's response to an agent prompt.
         */
        post: operations["respondAgentSession"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/license/activate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Activate a license key
         * @description Exchanges a license key for a signed JWT token. Admin only.
         */
        post: operations["activateLicense"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/license/deactivate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Deactivate the current license
         * @description Removes local activation data and returns to community mode. Admin only.
         */
        post: operations["deactivateLicense"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/docs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List documents
         * @description Returns documents as a tree structure or flat list. All authenticated users can browse.
         */
        get: operations["listDocs"];
        put?: never;
        /**
         * Create document
         * @description Creates a new document. Requires DAG write permission.
         */
        post: operations["createDoc"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/docs/search": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Search documents
         * @description Searches document content for the given query.
         */
        get: operations["searchDocs"];
        put?: never;
        post?: never;
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/docs/doc": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get document
         * @description Returns a single document by path.
         */
        get: operations["getDoc"];
        put?: never;
        post?: never;
        /**
         * Delete document
         * @description Deletes a document. Requires DAG write permission.
         */
        delete: operations["deleteDoc"];
        options?: never;
        head?: never;
        /**
         * Update document
         * @description Updates an existing document's content. Requires DAG write permission.
         */
        patch: operations["updateDoc"];
        trace?: never;
    };
    "/docs/doc/rename": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Rename document or directory
         * @description Renames/moves a document or directory to a new path. When a directory path is given, all documents under it are moved atomically. Requires DAG write permission.
         */
        post: operations["renameDoc"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/docs/delete-batch": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete multiple documents or directories
         * @description Deletes multiple documents and/or directories in a single operation. Supports recursive directory deletion. Not-found items are treated as successful deletes for idempotency. Requires DAG write permission.
         */
        post: operations["deleteDocBatch"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/remote-nodes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List all remote nodes
         * @description Returns remote nodes from both config file and store
         */
        get: operations["listRemoteNodes"];
        put?: never;
        /**
         * Create a new remote node
         * @description Creates a store-managed remote node
         */
        post: operations["createRemoteNode"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/remote-nodes/{remoteNodeId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * Get a remote node
         * @description Returns a single remote node by ID
         */
        get: operations["getRemoteNode"];
        put?: never;
        post?: never;
        /**
         * Delete a remote node
         * @description Deletes a store-managed remote node
         */
        delete: operations["deleteRemoteNode"];
        options?: never;
        head?: never;
        /**
         * Update a remote node
         * @description Updates a store-managed remote node
         */
        patch: operations["updateRemoteNode"];
        trace?: never;
    };
    "/remote-nodes/{remoteNodeId}/test-connection": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Test remote node connection
         * @description Tests connectivity to a remote node by making a health check request
         */
        post: operations["testRemoteNodeConnection"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/secrets": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /**
         * List secrets
         * @description Lists secret registry metadata. Plaintext values are never returned.
         */
        get: operations["listSecrets"];
        put?: never;
        /**
         * Create a secret
         * @description Creates Dagu-managed secret metadata in global scope or a named workspace and optionally writes an initial value. Plaintext values are write-only.
         */
        post: operations["createSecret"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/secrets/{secretId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get secret */
        get: operations["getSecret"];
        put?: never;
        post?: never;
        /** Delete secret */
        delete: operations["deleteSecret"];
        options?: never;
        head?: never;
        /** Update secret metadata */
        patch: operations["updateSecret"];
        trace?: never;
    };
    "/secrets/{secretId}/versions": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Write a new secret value version
         * @description Writes a new Dagu-managed value version. The value is write-only and is not returned.
         */
        post: operations["writeSecretVersion"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/secrets/{secretId}/disable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Disable secret */
        post: operations["disableSecret"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/secrets/{secretId}/enable": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /** Enable secret */
        post: operations["enableSecret"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/workspaces": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** List all workspaces */
        get: operations["listWorkspaces"];
        put?: never;
        /** Create a workspace */
        post: operations["createWorkspace"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/workspaces/{workspaceId}": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** Get workspace by ID */
        get: operations["getWorkspace"];
        put?: never;
        post?: never;
        /** Delete a workspace */
        delete: operations["deleteWorkspace"];
        options?: never;
        head?: never;
        /** Update a workspace */
        patch: operations["updateWorkspace"];
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        /**
         * @deprecated
         * @description Deprecated alias for Labels. Additional labels to apply to the DAG-run (format: key=value or key-only). Merged with labels defined in the DAG spec. Mutually exclusive with `labels`; the server returns HTTP 400 if both are set.
         */
        Tags: string[];
        /** @description Additional labels to apply to the DAG-run (format: key=value or key-only). Merged with labels defined in the DAG spec. Mutually exclusive with deprecated `tags`; the server returns HTTP 400 if both are set. */
        Labels: string[];
        /** @description A single audit log entry */
        AuditEntry: {
            /** @description Unique identifier for this entry */
            id: string;
            /**
             * Format: date-time
             * @description When the event occurred
             */
            timestamp: string;
            /** @description Category of the audit event (e.g., terminal, user, dag) */
            category: string;
            /** @description The action that was performed (e.g., session_start, command, login) */
            action: string;
            /** @description ID of the user who performed the action */
            userId: string;
            /** @description Username of the user who performed the action */
            username: string;
            /** @description JSON-encoded action-specific details */
            details?: string;
            /** @description Client IP address if available */
            ipAddress?: string;
        };
        /** @description Response containing audit log entries */
        AuditLogsResponse: {
            /** @description List of audit log entries */
            entries: components["schemas"]["AuditEntry"][];
            /** @description Total number of entries matching the filter (before pagination) */
            total: number;
        };
        /** @description A single centralized operational event log entry */
        EventLogEntry: {
            /** @description Unique identifier for this event */
            id: string;
            /** @description Schema version of the event envelope */
            schemaVersion: number;
            /**
             * Format: date-time
             * @description When the event occurred
             */
            occurredAt: string;
            /**
             * Format: date-time
             * @description When the event was recorded by the producer
             */
            recordedAt: string;
            /** @description High-level event kind (e.g., dag_run, llm_usage) */
            kind: string;
            /** @description Specific event type (e.g., dag.run.failed) */
            type: string;
            /** @description Service that produced the event */
            sourceService: string;
            /** @description Specific producer instance identifier */
            sourceInstance?: string;
            /** @description DAG name for DAG-run events */
            dagName?: string;
            /** @description DAG run ID for DAG-run events */
            dagRunId?: string;
            /** @description Attempt ID for DAG-run events */
            attemptId?: string;
            /** @description Session ID for LLM usage events */
            sessionId?: string;
            /** @description User ID associated with the event */
            userId?: string;
            /** @description Model name associated with the event */
            model?: string;
            /** @description Status associated with the event when applicable */
            status?: string;
            /** @description Small event-specific payload */
            data?: {
                [key: string]: unknown;
            };
        };
        /** @description Response containing centralized event log entries */
        EventLogsResponse: {
            /** @description List of event log entries */
            entries: components["schemas"]["EventLogEntry"][];
            /** @description Total number of entries matching the filter when using compatibility offset pagination */
            total?: number;
            /** @description Opaque cursor for loading the next page of older entries when using cursor pagination */
            nextCursor?: string;
        };
        /** @description Forward-only paginated DAG-run list response */
        DAGRunsPageResponse: {
            /** @description List of DAG-runs with their status and metadata */
            dagRuns: components["schemas"]["DAGRunSummary"][];
            /** @description Opaque cursor for loading the next page of older DAG-runs */
            nextCursor?: string;
        };
        /** @description Request body for approving a waiting step */
        ApproveStepRequest: {
            /** @description Key-value parameters to provide. These will be available as environment variables in subsequent steps. */
            inputs?: {
                [key: string]: string;
            };
        };
        /** @description Response after approving a waiting step */
        ApproveStepResponse: {
            /** @description The DAG run ID */
            dagRunId: string;
            /** @description The approved step name */
            stepName: string;
            /** @description Whether the DAG run was re-enqueued for execution */
            resumed: boolean;
        };
        /** @description A single chat message in an LLM session */
        ChatMessage: {
            /**
             * @description Message role in the session
             * @enum {string}
             */
            role: ChatMessageRole;
            /** @description Message content */
            content: string;
            /** @description Tool calls made by the assistant (only for assistant messages) */
            toolCalls?: components["schemas"]["ChatToolCall"][];
            metadata?: components["schemas"]["ChatMessageMetadata"];
        };
        /** @description A tool call requested by the LLM */
        ChatToolCall: {
            /** @description Unique identifier for this tool call */
            id: string;
            /** @description Name of the tool being called */
            name: string;
            /** @description JSON string of tool arguments */
            arguments?: string;
        };
        /** @description Metadata about an LLM API call */
        ChatMessageMetadata: {
            /** @description LLM provider (openai, anthropic, gemini, etc.) */
            provider?: string;
            /** @description Model identifier used */
            model?: string;
            /** @description Number of tokens in the prompt */
            promptTokens?: number;
            /** @description Number of tokens in the completion */
            completionTokens?: number;
            /** @description Total tokens (prompt + completion) */
            totalTokens?: number;
        };
        /** @description Response containing chat messages for a step */
        ChatMessagesResponse: {
            /** @description List of chat messages */
            messages: components["schemas"]["ChatMessage"][];
            /** @description Tool definitions that were available to the LLM */
            toolDefinitions?: components["schemas"]["ToolDefinition"][];
            stepStatus: components["schemas"]["NodeStatus"];
            stepStatusLabel: components["schemas"]["NodeStatusLabel"];
            /** @description True if step is still running and more messages may arrive */
            hasMore: boolean;
        };
        /** @description A tool definition that was available to the LLM */
        ToolDefinition: {
            /** @description Name of the tool */
            name: string;
            /** @description Description of what the tool does */
            description?: string;
            /** @description JSON Schema describing the tool's parameters */
            parameters?: {
                [key: string]: unknown;
            };
        };
        /** @description Request body for rejecting a waiting step */
        RejectStepRequest: {
            /** @description Optional reason for rejecting the step */
            reason?: string;
        };
        /** @description Response after rejecting a waiting step */
        RejectStepResponse: {
            /** @description The DAG run ID */
            dagRunId: string;
            /** @description The rejected step name */
            stepName: string;
        };
        /** @description Request body for pushing back a waiting step for re-execution with feedback */
        PushBackStepRequest: {
            /** @description Key-value parameters to provide as feedback. These will be injected as environment variables when the step re-executes. */
            inputs?: {
                [key: string]: string;
            };
        };
        /** @description Response after pushing back a waiting step */
        PushBackStepResponse: {
            /** @description The DAG run ID */
            dagRunId: string;
            /** @description The pushed-back step name */
            stepName: string;
            /** @description The current approval iteration count after push-back */
            approvalIteration: number;
            /** @description Whether the DAG run was re-enqueued for execution */
            resumed: boolean;
            /** @description The sub-DAG run ID, present only for sub-DAG push-back operations */
            subDAGRunId?: string;
        };
        /** @description Configuration for a human approval gate on a step */
        ApprovalConfig: {
            /** @description Message displayed to the approver */
            prompt?: string;
            /** @description List of expected input field names from the approver */
            input?: string[];
            /** @description Subset of input fields that must be provided */
            required?: string[];
            /** @description Optional step name to restart from when the approver pushes the step back. Must reference the step itself or an upstream dependency. */
            rewindTo?: string;
        };
        /** @description Generic error response object */
        Error: {
            code: components["schemas"]["ErrorCode"];
            /** @description Short error message */
            message: string;
            /** @description Additional error details */
            details?: Record<string, never>;
        };
        /** @description Timeout error response with DAG run tracking information */
        TimeoutError: components["schemas"]["Error"] & {
            dagRunId: components["schemas"]["DAGRunId"] & unknown;
        };
        /**
         * @description Error code indicating the type of error
         * @enum {string}
         */
        ErrorCode: ErrorCode;
        /** @description Request body for webhook trigger endpoint */
        WebhookRequest: {
            dagRunId?: components["schemas"]["DAGRunId"] & unknown;
            /** @description Arbitrary JSON payload to pass to the DAG as WEBHOOK_PAYLOAD */
            payload?: {
                [key: string]: unknown;
            };
        };
        /** @description Response from webhook trigger endpoint */
        WebhookResponse: {
            dagRunId: components["schemas"]["DAGRunId"];
            /** @description Name of the triggered DAG */
            dagName: string;
        };
        /**
         * @description Authentication mode for a webhook trigger endpoint
         * @enum {string}
         */
        WebhookAuthMode: WebhookAuthMode;
        /**
         * @description How HMAC validation is enforced when HMAC is enabled
         * @enum {string}
         */
        WebhookHMACEnforcementMode: WebhookHMACEnforcementMode;
        /** @description Public webhook HMAC configuration details */
        WebhookHMACDetails: {
            /** @description Whether HMAC authentication is currently enabled */
            enabled: boolean;
            enforcementMode?: components["schemas"]["WebhookHMACEnforcementMode"];
            /** @description Fixed HMAC algorithm for v1 */
            algorithm?: string;
            /** @description Header containing the HMAC signature */
            headerName?: string;
            /** @description Expected signature header value format */
            format?: string;
            /** @description Whether an HMAC secret is configured for the webhook */
            secretConfigured: boolean;
            /**
             * Format: date-time
             * @description When the HMAC secret was last generated
             */
            updatedAt?: string;
        };
        /** @description Webhook configuration details (token not included) */
        WebhookDetails: {
            /**
             * Format: uuid
             * @description Unique identifier for the webhook
             */
            id: string;
            /** @description Name of the DAG this webhook triggers */
            dagName: string;
            /** @description First 8 characters of the token for identification */
            tokenPrefix: string;
            /** @description Whether the webhook is active */
            enabled: boolean;
            authMode: components["schemas"]["WebhookAuthMode"];
            hmac: components["schemas"]["WebhookHMACDetails"];
            /**
             * Format: date-time
             * @description When the webhook was created
             */
            createdAt: string;
            /**
             * Format: date-time
             * @description When the webhook was last modified
             */
            updatedAt: string;
            /** @description User ID who created the webhook */
            createdBy?: string;
            /**
             * Format: date-time
             * @description When the webhook was last triggered
             */
            lastUsedAt?: string;
        };
        /** @description Response when creating or regenerating a webhook (includes full token) */
        WebhookCreateResponse: {
            webhook: components["schemas"]["WebhookDetails"];
            /** @description Full webhook token (only shown once, store securely!) */
            token: string;
        };
        /** @description List of all webhooks */
        WebhookListResponse: {
            webhooks: components["schemas"]["WebhookDetails"][];
        };
        /** @description Request to toggle webhook enabled state */
        WebhookToggleRequest: {
            /** @description Whether to enable or disable the webhook */
            enabled: boolean;
        };
        /** @description Request to configure webhook HMAC auth mode and enforcement.
         *     If enforcementMode is omitted when enabling HMAC, it defaults to strict.
         *     If omitted when configuring an existing webhook, the current enforcement
         *     mode is preserved for token_and_hmac, while hmac_only always uses strict.
         *     Clients should omit enforcementMode when authMode is hmac_only; the
         *     server enforces strict mode and rejects observe.
         *      */
        WebhookHMACConfigureRequest: {
            /** @enum {string} */
            authMode: WebhookHMACConfigureRequestAuthMode;
            enforcementMode?: components["schemas"]["WebhookHMACEnforcementMode"];
        };
        /** @description Response when enabling or regenerating webhook HMAC (includes full secret) */
        WebhookHMACSecretResponse: {
            webhook: components["schemas"]["WebhookDetails"];
            /** @description Full HMAC secret (only shown once, store securely!) */
            hmacSecret: string;
        };
        /**
         * @description Notification delivery provider
         * @enum {string}
         */
        NotificationProviderType: NotificationProviderType;
        /**
         * @description DAG run event that can trigger server-side notifications
         * @enum {string}
         */
        NotificationEventType: NotificationEventType;
        /** @description Email notification target. SMTP transport is configured in workspace notification settings. */
        NotificationEmailTarget: {
            /** @description Sender address. Defaults to the workspace SMTP sender. */
            from?: string;
            /** @description Primary recipients */
            to: string[];
            /** @description CC recipients */
            cc?: string[];
            /** @description BCC recipients */
            bcc?: string[];
            /** @description Subject prefix. Defaults to [DAGU]. */
            subjectPrefix?: string;
            /** @description Optional email subject template. When set, it replaces the generated subject. */
            subjectTemplate?: string;
            /** @description Optional email body template. When omitted, Dagu sends the default notification body. */
            bodyTemplate?: string;
            /** @description Attach DAG and step logs when available */
            attachLogs?: boolean;
        };
        /** @description Workspace SMTP transport input for notification email delivery. Values are encrypted at rest where applicable. */
        NotificationSMTPSettingsInput: {
            /** @description SMTP server host */
            host?: string;
            /** @description SMTP server port */
            port?: string;
            /** @description SMTP username */
            username?: string;
            /** @description SMTP password. Omit on updates to preserve the existing password. */
            password?: string;
            /** @description Clear the stored SMTP password. */
            clearPassword?: boolean;
            /** @description Default sender address for notification email channels */
            from?: string;
        };
        /** @description Public workspace SMTP transport settings. The SMTP password is never returned. */
        NotificationSMTPSettings: {
            /** @description SMTP server host */
            host?: string;
            /** @description SMTP server port */
            port?: string;
            /** @description SMTP username */
            username?: string;
            /** @description Default sender address for notification email channels */
            from?: string;
            /** @description Whether an SMTP password is configured */
            passwordConfigured: boolean;
        };
        /** @description Workspace-level notification settings input */
        NotificationWorkspaceSettingsInput: {
            smtp?: components["schemas"]["NotificationSMTPSettingsInput"] | null;
        };
        /** @description Workspace-level notification settings */
        NotificationWorkspaceSettings: {
            smtp?: components["schemas"]["NotificationSMTPSettings"];
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            updatedAt?: string;
            /** @description User ID that last updated the workspace notification settings */
            updatedBy?: string;
        };
        /**
         * @description Notification route scope
         * @enum {string}
         */
        NotificationRouteScope: NotificationRouteScope;
        /** @description Route from notification events to a notification channel */
        NotificationRouteInput: {
            /** @description Stable route ID. Omit when adding a route. */
            id?: string;
            /** @description Notification channel ID */
            channelId: string;
            /** @description Whether this route receives notifications */
            enabled: boolean;
            /** @description Events delivered by this route. Omit only for backward compatibility; new clients should send an explicit event list. */
            events?: components["schemas"]["NotificationEventType"][];
        };
        /** @description Route from notification events to a notification channel */
        NotificationRoute: {
            /** @description Stable route ID */
            id: string;
            /** @description Notification channel ID */
            channelId: string;
            /** @description Whether this route receives notifications */
            enabled: boolean;
            /** @description Events delivered by this route. Empty is treated as operational defaults for backward compatibility. */
            events?: components["schemas"]["NotificationEventType"][];
        };
        /** @description Replacement route set for a global or workspace notification scope */
        NotificationRouteSetInput: {
            /** @description Whether this route set can deliver notifications */
            enabled: boolean;
            /** @description For workspace route sets, true means inherit Global instead of using workspace routes. Ignored for global route sets. */
            inheritGlobal: boolean;
            routes: components["schemas"]["NotificationRouteInput"][];
        };
        /** @description Notification routes for a global or workspace scope */
        NotificationRouteSet: {
            /** @description Stable route set ID, present after the route set is saved */
            id?: string;
            scope: components["schemas"]["NotificationRouteScope"];
            /** @description Workspace name for workspace-scoped route sets */
            workspace?: string;
            /** @description Whether this route set can deliver notifications */
            enabled: boolean;
            /** @description For workspace route sets, true means inherit Global instead of using workspace routes */
            inheritGlobal: boolean;
            routes: components["schemas"]["NotificationRoute"][];
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            updatedAt?: string;
            /** @description User ID that last updated the route set */
            updatedBy?: string;
        };
        /** @description Notification route sets */
        NotificationRouteSetListResponse: {
            routeSets: components["schemas"]["NotificationRouteSet"][];
        };
        /** @description Outbound webhook target input. Values are encrypted at rest. */
        NotificationWebhookTargetInput: {
            /**
             * Format: uri
             * @description HTTP or HTTPS endpoint to POST notification payloads to. Omit on updates to preserve the existing URL.
             */
            url?: string;
            /** @description Additional request headers. Values are encrypted at rest. When provided, this replaces the stored header set. */
            headers?: {
                [key: string]: string;
            };
            /** @description Clear all stored webhook headers. */
            clearHeaders?: boolean;
            /** @description Optional HMAC secret for X-Dagu-Signature. Omit on updates to preserve the existing secret. */
            hmacSecret?: string;
            /** @description Clear the stored HMAC secret. */
            clearHmacSecret?: boolean;
            /** @description Optional rendered message added to the webhook JSON payload as message. */
            messageTemplate?: string;
            /** @description Allow plain HTTP webhook URLs. Disabled by default. */
            allowInsecureHttp?: boolean;
            /** @description Allow loopback or private network webhook targets. Disabled by default. */
            allowPrivateNetwork?: boolean;
        };
        /** @description Public outbound webhook target details */
        NotificationWebhookTarget: {
            /** @description Whether a webhook URL is configured */
            urlConfigured: boolean;
            /** @description Redacted URL preview */
            urlPreview?: string;
            /** @description Header names with redacted values */
            headers?: {
                [key: string]: string;
            };
            /** @description Whether an HMAC secret is configured */
            hmacSecretConfigured: boolean;
            /** @description Optional rendered message added to the webhook JSON payload as message. */
            messageTemplate?: string;
            /** @description Whether this target allows plain HTTP webhook URLs */
            allowInsecureHttp?: boolean;
            /** @description Whether this target allows loopback or private network webhook targets */
            allowPrivateNetwork?: boolean;
        };
        /** @description Slack incoming webhook target input. Values are encrypted at rest. */
        NotificationSlackTargetInput: {
            /**
             * Format: uri
             * @description Slack incoming webhook URL. Omit on updates to preserve the existing URL.
             */
            webhookUrl?: string;
            /** @description Optional Slack message template. When omitted, Dagu sends the default notification text. */
            messageTemplate?: string;
        };
        /** @description Public Slack target details */
        NotificationSlackTarget: {
            /** @description Whether a Slack incoming webhook URL is configured */
            webhookUrlConfigured: boolean;
            /** @description Redacted Slack webhook URL preview */
            webhookUrlPreview?: string;
            /** @description Optional Slack message template. When omitted, Dagu sends the default notification text. */
            messageTemplate?: string;
        };
        /** @description Telegram Bot API target input. Bot token is encrypted at rest. */
        NotificationTelegramTargetInput: {
            /** @description Telegram bot token. Omit on updates to preserve the existing token. */
            botToken?: string;
            /** @description Telegram chat ID */
            chatId?: string;
            /** @description Optional Telegram message template. When omitted, Dagu sends the default notification text. */
            messageTemplate?: string;
        };
        /** @description Public Telegram target details */
        NotificationTelegramTarget: {
            /** @description Whether a Telegram bot token is configured */
            botTokenConfigured: boolean;
            /** @description Redacted Telegram bot token preview */
            botTokenPreview?: string;
            /** @description Telegram chat ID */
            chatId?: string;
            /** @description Optional Telegram message template. When omitted, Dagu sends the default notification text. */
            messageTemplate?: string;
        };
        /** @description Notification target input */
        NotificationTargetInput: {
            /** @description Stable target ID. Omit when creating a new target. */
            id?: string;
            /** @description Human-readable target name */
            name?: string;
            type: components["schemas"]["NotificationProviderType"];
            /** @description Whether this target receives notifications */
            enabled: boolean;
            /** @description Optional target-level event filter. When omitted or empty, the target inherits DAG-level events. */
            events?: components["schemas"]["NotificationEventType"][];
            email?: components["schemas"]["NotificationEmailTarget"];
            webhook?: components["schemas"]["NotificationWebhookTargetInput"];
            slack?: components["schemas"]["NotificationSlackTargetInput"];
            telegram?: components["schemas"]["NotificationTelegramTargetInput"];
        };
        /** @description Public notification target details. Secrets are never returned. */
        NotificationTarget: {
            /** @description Stable target ID */
            id: string;
            /** @description Human-readable target name */
            name?: string;
            type: components["schemas"]["NotificationProviderType"];
            /** @description Whether this target receives notifications */
            enabled: boolean;
            /** @description Target-level event filter. Empty means the target inherits DAG-level events. */
            events?: components["schemas"]["NotificationEventType"][];
            email?: components["schemas"]["NotificationEmailTarget"];
            webhook?: components["schemas"]["NotificationWebhookTarget"];
            slack?: components["schemas"]["NotificationSlackTarget"];
            telegram?: components["schemas"]["NotificationTelegramTarget"];
        };
        /** @description Notification channel input */
        NotificationChannelInput: {
            /** @description Human-readable channel name */
            name: string;
            type: components["schemas"]["NotificationProviderType"];
            /** @description Whether this channel can receive notifications */
            enabled: boolean;
            email?: components["schemas"]["NotificationEmailTarget"];
            webhook?: components["schemas"]["NotificationWebhookTargetInput"];
            slack?: components["schemas"]["NotificationSlackTargetInput"];
            telegram?: components["schemas"]["NotificationTelegramTargetInput"];
        };
        /** @description Notification channel. Secrets are never returned. */
        NotificationChannel: {
            /** @description Stable channel ID */
            id: string;
            /** @description Human-readable channel name */
            name: string;
            type: components["schemas"]["NotificationProviderType"];
            /** @description Whether this channel can receive notifications */
            enabled: boolean;
            email?: components["schemas"]["NotificationEmailTarget"];
            webhook?: components["schemas"]["NotificationWebhookTarget"];
            slack?: components["schemas"]["NotificationSlackTarget"];
            telegram?: components["schemas"]["NotificationTelegramTarget"];
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            /** @description User ID that last updated the channel */
            updatedBy?: string;
        };
        /** @description Notification channels */
        NotificationChannelListResponse: {
            channels: components["schemas"]["NotificationChannel"][];
        };
        /** @description DAG subscription to a notification channel */
        NotificationSubscriptionInput: {
            /** @description Stable subscription ID. Omit when creating a new subscription. */
            id?: string;
            /** @description Notification channel ID */
            channelId: string;
            /** @description Whether this DAG subscription receives notifications */
            enabled: boolean;
            /** @description Optional subscription-level event filter. When omitted or empty, the subscription inherits DAG-level events. */
            events?: components["schemas"]["NotificationEventType"][];
        };
        /** @description DAG subscription to a notification channel */
        NotificationSubscription: {
            /** @description Stable subscription ID */
            id: string;
            /** @description Notification channel ID */
            channelId: string;
            /** @description Whether this DAG subscription receives notifications */
            enabled: boolean;
            /** @description Subscription-level event filter. Empty means the subscription inherits DAG-level events. */
            events?: components["schemas"]["NotificationEventType"][];
        };
        /** @description Server-side DAG notification settings */
        DAGNotificationSettings: {
            /** @description Stable settings ID */
            id: string;
            /** @description Name of the DAG these settings apply to */
            dagName: string;
            /** @description Whether notification delivery is enabled for this DAG */
            enabled: boolean;
            /** @description DAG run events that trigger notifications */
            events: components["schemas"]["NotificationEventType"][];
            /** @description DAG-local notification targets kept for backward compatibility */
            targets: components["schemas"]["NotificationTarget"][];
            /** @description Notification channels subscribed by this DAG */
            subscriptions: components["schemas"]["NotificationSubscription"][];
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            /** @description User ID that last updated the settings */
            updatedBy?: string;
        };
        /** @description Request to replace DAG notification settings */
        UpdateDAGNotificationsRequest: {
            /** @description Whether notification delivery is enabled for this DAG */
            enabled: boolean;
            events: components["schemas"]["NotificationEventType"][];
            targets: components["schemas"]["NotificationTargetInput"][];
            subscriptions?: components["schemas"]["NotificationSubscriptionInput"][];
        };
        /** @description Request to send a test notification */
        TestDAGNotificationRequest: {
            /** @description Optional DAG-local target ID, subscription ID, or channel ID. When omitted, every enabled target and subscription is tested. */
            targetId?: string;
            eventType?: components["schemas"]["NotificationEventType"];
        };
        /** @description Delivery result for one notification target */
        TestDAGNotificationResult: {
            targetId: string;
            targetName: string;
            provider: components["schemas"]["NotificationProviderType"];
            delivered: boolean;
            error?: string;
        };
        /** @description Result of test notification delivery */
        TestDAGNotificationResponse: {
            results: components["schemas"]["TestDAGNotificationResult"][];
        };
        /**
         * @description Incident provider type
         * @enum {string}
         */
        IncidentProviderType: IncidentProviderType;
        /**
         * @description Incident severity
         * @enum {string}
         */
        IncidentSeverity: IncidentSeverity;
        /**
         * @description Incident routing scope
         * @enum {string}
         */
        IncidentPolicyScope: IncidentPolicyScope;
        /** @description PagerDuty Events API v2 provider input. The routing key is encrypted at rest. */
        IncidentPagerDutyProviderInput: {
            /** @description PagerDuty Events API v2 routing key. Omit on updates to preserve the existing key. */
            routingKey?: string;
            /** @description Clear the stored routing key. */
            clearRoutingKey?: boolean;
        };
        /** @description Public PagerDuty provider details */
        IncidentPagerDutyProvider: {
            /** @description Whether a PagerDuty routing key is configured */
            routingKeyConfigured: boolean;
            /** @description Redacted routing key preview */
            routingKeyPreview?: string;
        };
        /** @description SolarWinds Incident Response incoming webhook provider input. The webhook URL is encrypted at rest. */
        IncidentSolarWindsProviderInput: {
            /**
             * Format: uri
             * @description Incoming webhook URL. Omit on updates to preserve the existing URL.
             */
            webhookUrl?: string;
            /** @description Clear the stored webhook URL. */
            clearWebhookUrl?: boolean;
            /** @description Allow plain HTTP webhook URLs. Disabled by default. */
            allowInsecureHttp?: boolean;
            /** @description Allow loopback or private network webhook targets. Disabled by default. */
            allowPrivateNetwork?: boolean;
        };
        /** @description Public SolarWinds Incident Response provider details */
        IncidentSolarWindsProvider: {
            /** @description Whether an incoming webhook URL is configured */
            webhookUrlConfigured: boolean;
            /** @description Redacted webhook URL preview */
            webhookUrlPreview?: string;
            /** @description Whether this provider allows plain HTTP webhook URLs */
            allowInsecureHttp?: boolean;
            /** @description Whether this provider allows loopback or private network webhook targets */
            allowPrivateNetwork?: boolean;
        };
        /** @description PagerDuty incident provider input */
        IncidentPagerDutyProviderInputEnvelope: {
            /** @description Human-readable provider name */
            name: string;
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: IncidentPagerDutyProviderInputEnvelopeType;
            /** @description Whether this provider can receive incident events */
            enabled: boolean;
            pagerDuty: components["schemas"]["IncidentPagerDutyProviderInput"];
        };
        /** @description SolarWinds Incident Response provider input */
        IncidentSolarWindsProviderInputEnvelope: {
            /** @description Human-readable provider name */
            name: string;
            /**
             * @description discriminator enum property added by openapi-typescript
             * @enum {string}
             */
            type: IncidentSolarWindsProviderInputEnvelopeType;
            /** @description Whether this provider can receive incident events */
            enabled: boolean;
            solarWinds: components["schemas"]["IncidentSolarWindsProviderInput"];
        };
        /** @description Incident provider input */
        IncidentProviderInput: components["schemas"]["IncidentPagerDutyProviderInputEnvelope"] | components["schemas"]["IncidentSolarWindsProviderInputEnvelope"];
        /** @description Incident provider. Secrets are never returned. */
        IncidentProvider: {
            /** @description Stable provider ID */
            id: string;
            /** @description Human-readable provider name */
            name: string;
            type: components["schemas"]["IncidentProviderType"];
            /** @description Whether this provider can receive incident events */
            enabled: boolean;
            pagerDuty?: components["schemas"]["IncidentPagerDutyProvider"];
            solarWinds?: components["schemas"]["IncidentSolarWindsProvider"];
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            /** @description User ID that last updated the provider */
            updatedBy?: string;
        };
        /** @description Incident providers */
        IncidentProviderListResponse: {
            providers: components["schemas"]["IncidentProvider"][];
        };
        /** @description Incident route input. A route opens an incident on final DAG failure and Dagu resolves the saved open incident on later success. */
        IncidentPolicyInput: {
            /** @description Stable route ID. Omit when adding a route. */
            id?: string;
            /** @description Incident provider ID */
            providerId: string;
            /** @description Whether this route is enabled. Normal incident routing sends true when the route exists. */
            enabled: boolean;
            severity: components["schemas"]["IncidentSeverity"];
            /** @description Deprecated. Dagu resolves saved open incidents on recovery. */
            resolveOnRecovery?: boolean;
            /** @description Deprecated and ignored. Dagu generates stable provider incident keys. */
            dedupKeyTemplate?: string;
            /** @description Template for the provider incident summary/message. */
            messageTemplate?: string;
            /** @description Template for the provider incident description/details. */
            descriptionTemplate?: string;
        };
        /** @description Incident route */
        IncidentPolicy: {
            /** @description Stable route ID */
            id: string;
            /** @description Incident provider ID */
            providerId: string;
            /** @description Whether this route is enabled */
            enabled: boolean;
            severity: components["schemas"]["IncidentSeverity"];
            /** @description Deprecated. Dagu resolves saved open incidents on recovery. */
            resolveOnRecovery: boolean;
            /** @description Deprecated and ignored. Dagu generates stable provider incident keys. */
            dedupKeyTemplate: string;
            /** @description Template for the provider incident summary/message */
            messageTemplate: string;
            /** @description Template for the provider incident description/details */
            descriptionTemplate: string;
        };
        /** @description Replacement incident routing for a global, workspace, or DAG scope */
        IncidentPolicySetInput: {
            /** @description Whether this scope can open new incidents */
            enabled: boolean;
            /** @description For workspace and DAG routing, true means inherit the parent scope instead of using local routes. Ignored for global routing. */
            inheritParent: boolean;
            policies: components["schemas"]["IncidentPolicyInput"][];
        };
        /** @description Incident routing for a global, workspace, or DAG scope */
        IncidentPolicySet: {
            /** @description Stable routing ID, present after routing is saved */
            id?: string;
            scope: components["schemas"]["IncidentPolicyScope"];
            /** @description Workspace name for workspace-scoped routing */
            workspace?: string;
            /** @description DAG name for DAG-scoped routing */
            dagName?: string;
            /** @description Whether this scope can open new incidents */
            enabled: boolean;
            /** @description For workspace and DAG routing, true means inherit the parent scope instead of using local routes */
            inheritParent: boolean;
            policies: components["schemas"]["IncidentPolicy"][];
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            updatedAt?: string;
            /** @description User ID that last updated routing */
            updatedBy?: string;
        };
        /** @description Incident routing scopes */
        IncidentPolicySetListResponse: {
            policySets: components["schemas"]["IncidentPolicySet"][];
        };
        /** @description Delivery result for one incident provider */
        TestIncidentProviderResult: {
            providerId: string;
            providerName: string;
            providerType: components["schemas"]["IncidentProviderType"];
            delivered: boolean;
            error?: string;
        };
        /** @description Result of test incident delivery */
        TestIncidentProviderResponse: {
            result: components["schemas"]["TestIncidentProviderResult"];
        };
        /**
         * Format: string
         * @enum {string}
         */
        Stream: Stream;
        /**
         * Format: int64
         * @description Unix timestamp in seconds
         * @example 1672531199
         */
        UnixTimestamp: number;
        /**
         * Format: regex
         * @description Name of the DAG file
         */
        DAGFileName: string;
        /**
         * Format: regex
         * @description Name of the DAG
         */
        DAGName: string;
        Pagination: {
            /** @description total number of records */
            totalRecords: number;
            /** @description current page number */
            currentPage: number;
            /** @description total number of pages */
            totalPages: number;
            /** @description next page number */
            nextPage: number;
            /** @description previous page number */
            prevPage: number;
        };
        /**
         * @description Unique identifier for the DAG-run. The special value 'latest' can be used to reference the most recent DAG-run.
         * @example latest
         */
        DAGRunId: string;
        /**
         * @description Unique identifier for a newly-created DAG-run. The special value 'latest' is not allowed.
         * @example 20240101_120000
         */
        DAGRunCreateId: string;
        /** @description Response object for the health check endpoint */
        HealthResponse: {
            /**
             * @description Overall health status of the server
             * @enum {string}
             */
            status: HealthResponseStatus;
            /** @description Current version of the server */
            version: string;
            /** @description Server uptime in seconds */
            uptime: number;
            /** @description Current server time */
            timestamp: string;
        };
        /** @description DAG file with its status information */
        DAGFile: {
            /** @description File ID of the DAG file */
            fileName: string;
            /** @description Absolute file path of the DAG file on disk */
            filePath?: string;
            dag: components["schemas"]["DAG"];
            latestDAGRun: components["schemas"]["DAGRunSummary"];
            /**
             * Format: date-time
             * @description Scheduler-aware next planned run time. Pending overdue one-offs remain visible until consumed.
             */
            nextRun?: string;
            /** @description Whether the DAG is suspended */
            suspended: boolean;
            /** @description List of errors encountered during the request */
            errors: string[];
        };
        /** @description Core DAG configuration containing definition and metadata */
        DAG: {
            /** @description Logical grouping of related DAGs for organizational purposes */
            group?: string;
            /** @description Logical name of the DAG */
            name: string;
            /** @description Workspace label value for the DAG. Omitted for default DAGs and invalid workspace labels. */
            workspace?: string;
            /** @description List of scheduling expressions defining when DAG-runs should be created from this DAG */
            schedule?: components["schemas"]["Schedule"][];
            /** @description Human-readable description of the DAG's purpose and behavior */
            description?: string;
            /** @description List of parameter names that can be passed to DAG-runs created from this DAG */
            params?: string[];
            /** @description Default parameter values in JSON format if not specified at DAG-run creation */
            defaultParams?: string;
            /** @description List of labels for categorizing and filtering DAGs */
            labels?: string[];
            /**
             * @deprecated
             * @description Deprecated alias for labels. List of labels for categorizing and filtering DAGs
             */
            tags?: string[];
            /** @description Name of the queue this DAG is assigned to. If not specified, the DAG name itself becomes the queue name */
            queue?: string;
            /**
             * @deprecated
             * @description DEPRECATED: This field is ignored for local (DAG-based) queues. For concurrency control, use global queues
             */
            maxActiveRuns?: number;
            runConfig?: components["schemas"]["RunConfig"];
            resources?: components["schemas"]["DAGResources"];
        };
        /** @description Schedule configuration for DAG-run creation */
        Schedule: {
            /**
             * @description Schedule type. When omitted alongside expression, the schedule is treated as cron for backward compatibility.
             * @enum {string}
             */
            kind?: ScheduleKind;
            /** @description Cron expression for recurring schedules */
            expression?: string;
            /**
             * Format: date-time
             * @description RFC 3339 timestamp with explicit offset for one-off schedules
             */
            at?: string;
        };
        /**
         * @description Numeric status code indicating current DAG-run state:
         *     0: "Not started"
         *     1: "Running"
         *     2: "Failed"
         *     3: "Aborted"
         *     4: "Success"
         *     5: "Queued"
         *     6: "Partial Success"
         *     7: "Waiting for approval"
         *     8: "Rejected"
         *
         * @enum {integer}
         */
        Status: Status;
        /**
         * @description Human-readable status description for the DAG-run
         * @enum {string}
         */
        StatusLabel: StatusLabel;
        /**
         * @description How the DAG-run was initiated
         * @enum {string}
         */
        TriggerType: TriggerType;
        /**
         * @description Numeric status code indicating current node state:
         *     0: "Not started"
         *     1: "Running"
         *     2: "Failed"
         *     3: "Aborted"
         *     4: "Success"
         *     5: "Skipped"
         *     6: "Partial Success"
         *     7: "Waiting for approval"
         *     8: "Rejected"
         *     9: "Retrying"
         *
         * @enum {integer}
         */
        NodeStatus: NodeStatus;
        /**
         * @description Human-readable status description for the node
         * @enum {string}
         */
        NodeStatusLabel: NodeStatusLabel;
        /** @description Response containing status of all scheduler instances */
        SchedulerStatusResponse: {
            /** @description List of all registered scheduler instances */
            schedulers: components["schemas"]["SchedulerInstance"][];
        };
        /** @description Scheduler instance status information */
        SchedulerInstance: {
            /** @description Unique identifier of the scheduler instance */
            instanceId: string;
            /** @description Hostname where scheduler is running */
            host: string;
            /**
             * @description Scheduler status (active = holds lock and scheduling)
             * @enum {string}
             */
            status: SchedulerInstanceStatus;
            /** @description RFC3339 timestamp when scheduler started */
            startedAt: string;
        };
        /** @description Response containing status of all coordinator instances */
        CoordinatorStatusResponse: {
            /** @description List of all registered coordinator instances */
            coordinators: components["schemas"]["CoordinatorInstance"][];
        };
        /** @description Coordinator instance status information */
        CoordinatorInstance: {
            /** @description Unique identifier of the coordinator instance */
            instanceId: string;
            /** @description Hostname where coordinator is running */
            host: string;
            /**
             * @description Coordinator status
             * @enum {string}
             */
            status: CoordinatorInstanceStatus;
            /** @description RFC3339 timestamp when coordinator started */
            startedAt: string;
            /** @description Port number the coordinator is listening on */
            port: number;
        };
        /** @description Response containing tunnel service status */
        TunnelStatusResponse: {
            /** @description Whether tunneling is enabled in configuration */
            enabled: boolean;
            /**
             * @description The tunnel provider in use
             * @enum {string}
             */
            provider?: TunnelStatusResponseProvider;
            /**
             * @description Current status of the tunnel
             * @enum {string}
             */
            status: TunnelStatusResponseStatus;
            /**
             * Format: uri
             * @description The public URL provided by the tunnel
             */
            publicUrl?: string;
            /** @description Error message if tunnel failed */
            error?: string;
            /**
             * Format: date-time
             * @description RFC3339 timestamp when tunnel connected
             */
            startedAt?: string;
            /** @description Tunnel mode (e.g., 'direct' or 'funnel' for Tailscale) */
            mode?: string;
            /** @description Whether the tunnel provides public internet access */
            isPublic?: boolean;
        };
        /**
         * @description Health status of the worker based on heartbeat recency
         * @enum {string}
         */
        WorkerHealthStatus: WorkerHealthStatus;
        /** @description Detailed DAG configuration information */
        DAGDetails: {
            /**
             * Format: date-time
             * @description Scheduler-aware next planned run time. Pending overdue one-offs remain visible until consumed.
             */
            nextRun?: string;
            /** @description Logical grouping of related DAGs for organizational purposes */
            group?: string;
            /** @description Unique identifier for the DAG within its group */
            name: string;
            /** @description List of scheduling expressions defining when DAG-runs should be created from this DAG */
            schedule?: components["schemas"]["Schedule"][];
            /** @description Human-readable description of the DAG's purpose and behavior */
            description?: string;
            /** @description List of environment variables to set before executing a DAG-run */
            env?: string[];
            /** @description Directory path for storing log files */
            logDir?: string;
            artifacts?: components["schemas"]["DAGArtifactsConfig"];
            handlerOn?: components["schemas"]["HandlerOn"];
            /** @description List of steps to execute in DAG-runs created from this DAG */
            steps?: components["schemas"]["Step"][];
            /** @description Time in seconds to wait before starting a DAG-run */
            delay?: number;
            /** @description Number of days to retain historical logs */
            histRetentionDays?: number;
            /** @description Number of DAG runs to retain historical logs. Mutually exclusive with histRetentionDays. */
            histRetentionRuns?: number;
            /** @description Conditions that must be met before a DAG-run can start */
            preconditions?: components["schemas"]["Condition"][];
            /**
             * @deprecated
             * @description DEPRECATED: This field is ignored for local (DAG-based) queues. For concurrency control, use global queues
             */
            maxActiveRuns?: number;
            /** @description Name of the queue this DAG is assigned to. If not specified, the DAG name itself becomes the queue name */
            queue?: string;
            /** @description Maximum number of concurrent steps allowed in a DAG run */
            maxActiveSteps?: number;
            /** @description List of parameter names that can be passed to DAG-runs created from this DAG */
            params?: string[];
            /** @description Ordered parameter definitions derived from DAG params for typed UI rendering and validation */
            paramDefs?: components["schemas"]["ParamDef"][];
            /** @description Resolved JSON Schema for schema-backed DAG params when safe for direct UI form rendering */
            paramSchema?: {
                [key: string]: unknown;
            };
            /** @description Default parameter values in JSON format if not specified at DAG-run creation */
            defaultParams?: string;
            /** @description List of labels for categorizing and filtering DAGs */
            labels?: string[];
            /**
             * @deprecated
             * @description Deprecated alias for labels. List of labels for categorizing and filtering DAGs
             */
            tags?: string[];
            runConfig?: components["schemas"]["RunConfig"];
            resources?: components["schemas"]["DAGResources"];
        };
        /** @description Editor-only metadata used to synthesize per-document schema hints */
        DAGEditorHints: {
            /** @description Deprecated legacy execution definitions inherited from base config and available to the current DAG */
            inheritedLegacyDefinitions: components["schemas"]["InheritedLegacyDefinitionHint"][];
            /** @description Custom actions inherited from base config and available to the current DAG */
            inheritedCustomActions?: components["schemas"]["InheritedCustomActionHint"][];
        };
        /** @description Resolved editor hint for an inherited custom action */
        InheritedCustomActionHint: {
            /** @description Custom action name */
            name: string;
            /** @description Optional custom action description */
            description?: string;
            /** @description Resolved JSON Schema object used to validate and document with input */
            inputSchema: {
                [key: string]: unknown;
            };
            /** @description Resolved JSON Schema object used to validate stdout JSON output */
            outputSchema?: {
                [key: string]: unknown;
            };
        };
        /** @description Resolved editor hint for an inherited deprecated legacy execution definition */
        InheritedLegacyDefinitionHint: {
            /** @description Deprecated legacy execution definition name */
            name: string;
            /** @description Builtin executor type that the deprecated legacy execution definition expands to */
            targetType: string;
            /** @description Optional deprecated legacy execution definition description */
            description?: string;
            /** @description Resolved JSON Schema object used to validate and document with input */
            inputSchema: {
                [key: string]: unknown;
            };
            /** @description Resolved JSON Schema object used to validate stdout JSON output */
            outputSchema?: {
                [key: string]: unknown;
            };
        };
        /** @description Scalar parameter value */
        ParamScalar: string | number | boolean;
        /** @description Typed metadata for a single DAG parameter */
        ParamDef: {
            /** @description Parameter name. Omitted for positional parameters. */
            name?: string;
            /**
             * @description Parameter type
             * @enum {string}
             */
            type: ParamDefType;
            default?: components["schemas"]["ParamScalar"];
            description?: string;
            /** @default false */
            required: boolean;
            enum?: components["schemas"]["ParamScalar"][];
            /** Format: double */
            minimum?: number;
            /** Format: double */
            maximum?: number;
            minLength?: number;
            maxLength?: number;
            pattern?: string;
        };
        /** @description Configuration for controlling user interactions when starting DAG runs */
        RunConfig: {
            /**
             * @description Disable parameter editing when starting the DAG
             * @default false
             */
            disableParamEdit: boolean;
            /**
             * @description Disable custom run ID specification
             * @default false
             */
            disableRunIdEdit: boolean;
        };
        /** @description Resource limits requested for a DAG run */
        DAGResources: {
            limits?: components["schemas"]["DAGResourceLimits"];
        };
        /** @description CPU and memory limits requested for a DAG run */
        DAGResourceLimits: {
            /** @description CPU limit as cores (for example, "2" or "0.5") or millicores (for example, "500m") */
            cpu?: string;
            /** @description Memory limit in bytes or with a unit suffix (for example, "512Mi", "1Gi", or "2G") */
            memory?: string;
        };
        /** @description Configuration for DAG run artifact storage */
        DAGArtifactsConfig: {
            /** @description Whether artifact storage is enabled for this DAG */
            enabled: boolean;
            /** @description Base directory for storing artifacts for this DAG when explicitly configured */
            dir?: string;
        };
        LocalDag: {
            /** @description Name of the local DAG */
            name: string;
            dag?: components["schemas"]["DAGDetails"];
            /** @description List of errors encountered while processing the local DAG */
            errors: string[];
        };
        /** @description Configuration for event handlers in a DAG-run */
        HandlerOn: {
            failure?: components["schemas"]["Step"];
            success?: components["schemas"]["Step"];
            abort?: components["schemas"]["Step"];
            exit?: components["schemas"]["Step"];
        };
        /** @description Current status of a DAG-run */
        DAGRunSummary: {
            dagRunId: components["schemas"]["DAGRunId"];
            name: components["schemas"]["DAGName"];
            /** @description Workspace label value for the DAG-run. Omitted for default DAG-runs and invalid workspace labels. */
            workspace?: string;
            status: components["schemas"]["Status"];
            statusLabel: components["schemas"]["StatusLabel"];
            /** @description RFC 3339 timestamp when the DAG-run was queued */
            queuedAt?: string;
            /** @description Number of scheduler-issued DAG auto-retries already consumed for this DAG-run */
            autoRetryCount: number;
            /** @description Configured DAG-level automatic retry limit captured for this DAG-run; null when DAG-level automatic retry is not configured */
            autoRetryLimit?: number | null;
            /** @description RFC 3339 timestamp of when the DAG-run was scheduled to run */
            scheduleTime?: string;
            /** @description RFC 3339 timestamp when the DAG-run started */
            startedAt: string;
            /** @description RFC 3339 timestamp when the DAG-run finished */
            finishedAt: string;
            /** @description Whether artifact files are available for this DAG-run */
            artifactsAvailable: boolean;
            /** @description Runtime parameters passed to the DAG-run in JSON format */
            params?: string;
            /** @description ID of the worker that executed this DAG-run ('local' for local execution) */
            workerId?: string;
            triggerType?: components["schemas"]["TriggerType"];
            /** @description List of labels for categorizing and filtering DAG runs */
            labels?: string[];
            /**
             * @deprecated
             * @description Deprecated alias for labels. List of labels for categorizing and filtering DAG runs
             */
            tags?: string[];
        };
        /** @description Detailed status of a DAG-run including sub DAG-run nodes */
        DAGRunDetails: components["schemas"]["DAGRunSummary"] & {
            /** @description Name of the root DAG-run */
            rootDAGRunName: string;
            rootDAGRunId: components["schemas"]["DAGRunId"] & unknown;
            /** @description Name of the parent DAG-run */
            parentDAGRunName?: string;
            parentDAGRunId?: components["schemas"]["DAGRunId"] & unknown;
            /** @description Path to the log file */
            log: string;
            /** @description Status of individual steps within the DAG-run */
            nodes: components["schemas"]["Node"][];
            onExit?: components["schemas"]["Node"];
            onSuccess?: components["schemas"]["Node"];
            onFailure?: components["schemas"]["Node"];
            onAbort?: components["schemas"]["Node"];
            /** @description List of preconditions that must be met before the DAG-run can start */
            preconditions?: components["schemas"]["Condition"][];
            /** @description Whether this DAG-run still has a usable source file on disk, so reschedule can load the current spec from that file instead of the stored historical YAML snapshot. */
            specFromFile?: boolean;
            /** @description File name of the source DAG definition, derived from the DAG-run's source file path. Only set when the source file still exists on disk. Can be used to navigate to the DAG definition page. */
            sourceFileName?: components["schemas"]["DAGFileName"];
        };
        /**
         * @description Artifact tree node type
         * @enum {string}
         */
        ArtifactNodeType: ArtifactNodeType;
        /** @description A single file or directory in a DAG-run artifact tree */
        ArtifactTreeNode: {
            /** @description Display name of the artifact entry */
            name: string;
            /** @description Relative path of the artifact entry within the artifact directory */
            path: string;
            type: components["schemas"]["ArtifactNodeType"];
            /**
             * Format: int64
             * @description Size of the artifact file in bytes
             */
            size?: number;
            /** @description Nested artifact entries when this node is a directory */
            children?: components["schemas"]["ArtifactTreeNode"][];
        };
        /** @description Artifact tree for a DAG-run */
        ArtifactTreeResponse: {
            items: components["schemas"]["ArtifactTreeNode"][];
        };
        /**
         * @description Preview mode for an artifact file
         * @enum {string}
         */
        ArtifactPreviewKind: ArtifactPreviewKind;
        /** @description Preview metadata and optional inline content for a DAG-run artifact file */
        ArtifactPreviewResponse: {
            /** @description Artifact file name */
            name: string;
            /** @description Relative artifact file path */
            path: string;
            kind: components["schemas"]["ArtifactPreviewKind"];
            /** @description Detected MIME type for the artifact file */
            mimeType: string;
            /**
             * Format: int64
             * @description Artifact file size in bytes
             */
            size: number;
            /** @description Whether the artifact exceeds the inline preview size limit */
            tooLarge: boolean;
            /** @description Whether inline text content was truncated for preview */
            truncated: boolean;
            /** @description Inline preview content for markdown or text artifacts */
            content?: string;
        };
        /** @description Collected outputs from step executions in a DAG-run, including execution metadata. Outputs are populated from string-form output, stdout.outputs, and outputs.write. If the DAG-run completed but no outputs were captured, the outputs object will be empty and metadata fields may be empty strings. */
        DAGRunOutputs: {
            metadata: components["schemas"]["OutputsMetadata"];
            /**
             * @description Collected step outputs as key-value pairs. String-form output names are converted from UPPER_CASE to camelCase; stdout.outputs and outputs.write keys are preserved. Values are strings in this API response. Empty object if no outputs were captured.
             * @example {
             *       "totalCount": "42",
             *       "resultFile": "/path/to/result.txt",
             *       "config": "{\"key\": \"value\"}"
             *     }
             */
            outputs: {
                [key: string]: string;
            };
        };
        /** @description Execution context metadata for the outputs */
        OutputsMetadata: {
            dagName: components["schemas"]["DAGName"];
            dagRunId: components["schemas"]["DAGRunId"];
            /** @description Attempt identifier within the run */
            attemptId: string;
            status: components["schemas"]["StatusLabel"];
            /**
             * Format: date-time
             * @description RFC3339 timestamp when execution completed
             */
            completedAt: string;
            /** @description JSON-serialized parameters passed to the DAG */
            params?: string;
        };
        /** @description Status of an individual step within a DAG-run */
        Node: {
            step: components["schemas"]["Step"];
            /** @description Path to the standard output log file for this step */
            stdout: string;
            /** @description Path to the standard error log file for this step */
            stderr: string;
            /** @description RFC3339 timestamp when the step started */
            startedAt: string;
            /** @description RFC3339 timestamp when the step finished */
            finishedAt: string;
            status: components["schemas"]["NodeStatus"];
            statusLabel: components["schemas"]["NodeStatusLabel"];
            /** @description Number of retry attempts made for this step */
            retryCount: number;
            /** @description Number of successful completions for repeating steps */
            doneCount: number;
            /** @description List of sub DAG-runs associated with this step */
            subRuns?: components["schemas"]["SubDAGRun"][];
            /** @description List of repeated sub DAG-runs when using repeatPolicy */
            subRunsRepeated?: components["schemas"]["SubDAGRun"][];
            /** @description Error message if the step failed */
            error?: string;
            /** @description RFC3339 timestamp when the step was approved */
            approvedAt?: string;
            /** @description Username of who approved the step */
            approvedBy?: string;
            /** @description Key-value inputs provided during approval */
            approvalInputs?: {
                [key: string]: string;
            };
            /** @description RFC3339 timestamp when the step was rejected */
            rejectedAt?: string;
            /** @description Username of who rejected the step */
            rejectedBy?: string;
            /** @description Optional reason for rejection */
            rejectionReason?: string;
            /** @description Number of times this step has been pushed back for re-execution */
            approvalIteration?: number;
            /** @description Key-value inputs from the last push-back, injected as environment variables during re-execution */
            pushBackInputs?: {
                [key: string]: string;
            };
            /** @description Chronological push-back history for this step */
            pushBackHistory?: components["schemas"]["PushBackHistoryEntry"][];
        };
        /** @description One push-back event recorded for an approval step */
        PushBackHistoryEntry: {
            /** @description Push-back iteration number */
            iteration: number;
            /** @description Authenticated user who pushed the step back */
            by?: string;
            /**
             * Format: date-time
             * @description RFC3339 timestamp when the push-back was recorded
             */
            at?: string;
            /** @description Inputs provided for this push-back event */
            inputs?: {
                [key: string]: string;
            };
        };
        /** @description Metadata for a sub DAG-run */
        SubDAGRun: {
            dagRunId: components["schemas"]["DAGRunId"];
            /** @description Parameters passed to the sub DAG-run in JSON format */
            params?: string;
            /** @description Name of the executed sub-DAG. For chat tool calls, this is the tool DAG name. */
            dagName?: string;
        };
        /** @description Detailed information for a sub DAG-run including timing and status */
        SubDAGRunDetail: {
            dagRunId: components["schemas"]["DAGRunId"];
            /** @description Parameters passed to the sub DAG-run in JSON format */
            params?: string;
            /** @description Name of the executed sub-DAG. For chat tool calls, this is the tool DAG name. */
            dagName?: string;
            status: components["schemas"]["Status"];
            statusLabel: components["schemas"]["StatusLabel"];
            /** @description RFC 3339 timestamp when the sub DAG-run started */
            startedAt: string;
            /** @description RFC 3339 timestamp when the sub DAG-run finished */
            finishedAt?: string;
        };
        /** @description Individual task definition that performs a specific operation in a DAG-run */
        Step: {
            /** @description Unique identifier for the step within the DAG-run */
            name: string;
            /** @description Optional short identifier for the step. Can be used in variable references like ${id.stdout} to access step properties. Must be unique within the DAG if specified */
            id?: string;
            /** @description Human-readable description of what the step does */
            description?: string;
            /** @description Working directory for executing the step's command */
            dir?: string;
            /** @description List of commands to execute sequentially */
            commands?: components["schemas"]["CommandEntry"][];
            /** @description Script content if the step executes a script file */
            script?: string;
            /** @description File path for capturing standard output */
            stdout?: string;
            /** @description File path for capturing standard error */
            stderr?: string;
            /** @description Variable name to store the step's output */
            output?: string;
            /** @description The name of the DAG to execute as a sub DAG-run */
            call?: string;
            /** @description Parameters to pass to the sub DAG-run in JSON format */
            params?: string;
            /** @description Configuration for parallel execution of the step */
            parallel?: {
                /** @description Array of items to process in parallel. Can be a static array or a reference to a variable containing an array */
                items?: string[] | string;
                /** @description Maximum number of parallel executions. Default is 10 if not specified */
                maxConcurrent?: number;
            };
            /** @description List of step names that must complete before this step can start */
            depends?: string[];
            repeatPolicy?: components["schemas"]["RepeatPolicy"];
            /** @description Whether to send email notifications on step failure */
            mailOnError?: boolean;
            /** @description Conditions that must be met before the step can start */
            preconditions?: components["schemas"]["Condition"][];
            /** @description Maximum execution time for the step in seconds. If set, this timeout takes precedence over the DAG-level timeout for this step. */
            timeoutSec?: number;
            /** @description Executor configuration for this step */
            executorConfig?: {
                /** @description Type of executor (e.g., 'wait', 'http', 'docker', 'command') */
                type?: string;
                /** @description Executor-specific configuration */
                config?: {
                    [key: string]: unknown;
                };
            };
            /** @description Router configuration for switch/case routing */
            router?: {
                /** @description Expression to evaluate (e.g., '${STATUS}') */
                value: string;
                routes: {
                    /** @description Match pattern (exact or 're:regex') */
                    pattern: string;
                    /** @description Step names to route to */
                    targets: string[];
                }[];
            };
            approval?: components["schemas"]["ApprovalConfig"];
        };
        /** @description Individual search result item for a DAG */
        SearchResultItem: {
            /** @description Name of the matching DAG */
            name: string;
            dag: components["schemas"]["DAG"];
            /** @description Details of where matches were found */
            matches: components["schemas"]["SearchMatchItem"][];
        };
        /** @description Lightweight cursor-based search result item for a DAG */
        DAGSearchPageItem: {
            /** @description DAG file name without extension */
            fileName: string;
            /** @description Display label for the DAG result; file-backed search currently mirrors fileName */
            name: string;
            /** @description Workspace label value for the matching DAG. Omitted for default DAGs and invalid workspace labels. */
            workspace?: string;
            /** @description Whether additional snippets are available beyond the preview */
            hasMoreMatches: boolean;
            /** @description Opaque cursor for loading more snippets for this DAG result */
            nextMatchesCursor?: string;
            /** @description Preview snippets for the result */
            matches: components["schemas"]["SearchMatchItem"][];
        };
        /** @description Cursor-based DAG search results */
        DAGSearchFeedResponse: {
            results: components["schemas"]["DAGSearchPageItem"][];
            hasMore: boolean;
            nextCursor?: string;
        };
        /** @description Lightweight cursor-based search result item for a document */
        DocSearchPageItem: {
            id: string;
            title: string;
            /** @description Short document description from YAML frontmatter */
            description: string;
            /** @description Workspace that owns this document. Omitted for default documents. */
            workspace?: string;
            /** @description Whether additional snippets are available beyond the preview */
            hasMoreMatches: boolean;
            /** @description Opaque cursor for loading more snippets for this document result */
            nextMatchesCursor?: string;
            /** @description Preview snippets for the result */
            matches: components["schemas"]["SearchMatchItem"][];
        };
        /** @description Cursor-based document search results */
        DocSearchFeedResponse: {
            results: components["schemas"]["DocSearchPageItem"][];
            hasMore: boolean;
            nextCursor?: string;
        };
        /** @description Details of a search match within a search result */
        SearchMatchItem: {
            /** @description Matching line content */
            line: string;
            /** @description Line number where match was found */
            lineNumber: number;
            /** @description Start line for context */
            startLine: number;
        };
        /** @description Cursor-based search match snippets */
        SearchMatchesResponse: {
            matches: components["schemas"]["SearchMatchItem"][];
            hasMore: boolean;
            nextCursor?: string;
        };
        /** @description Log information for the execution */
        Log: {
            /** @description Log content */
            content: string;
            /** @description Number of lines returned */
            lineCount?: number;
            /** @description Total number of lines in the log file */
            totalLines?: number;
            /** @description Whether there are more lines available */
            hasMore?: boolean;
            /** @description Whether the line count is an estimate */
            isEstimate?: boolean;
        };
        /** @description Grid item for visualizing DAG-run execution history */
        DAGGridItem: {
            /** @description Name of the step */
            name: string;
            /** @description Status of the step ordered by time */
            history: components["schemas"]["NodeStatus"][];
        };
        /** @description Precondition that must be satisfied before running a step or DAG-run */
        Condition: {
            /** @description Expression or check to evaluate. When `expected` is omitted, the value runs as a command check using the same variable expansion rules as shell `command` steps. */
            condition: string;
            /** @description Expected result of the condition evaluation. When set, Dagu compares the evaluated string output instead of using command exit status. */
            expected?: string;
            /** @description If true, inverts the condition result (run when condition does NOT match) */
            negate?: boolean;
            /** @description Error message if the condition is not met */
            error?: string;
            /** @description Whether the condition was met */
            matched?: boolean;
        };
        /**
         * @description Repeat execution mode for steps
         * @enum {string}
         */
        RepeatMode: RepeatMode;
        /** @description Configuration for step repeat behavior */
        RepeatPolicy: {
            repeat?: components["schemas"]["RepeatMode"];
            /** @description Time in seconds to wait between repeat attempts */
            interval?: number;
            /** @description Maximum number of times to repeat the step */
            limit?: number;
            backoff?: boolean | number;
            /** @description Maximum interval in seconds (caps exponential growth) */
            maxIntervalSec?: number;
            condition?: components["schemas"]["Condition"];
            /** @description List of exit codes that trigger repeat behavior */
            exitCode?: number[];
        };
        /** @description A command with its arguments */
        CommandEntry: {
            /** @description The command to execute */
            command: string;
            /** @description Arguments for the command */
            args?: string[];
        };
        /** @description Response object for listing all labels */
        ListLabelResponse: {
            /** @description List of unique labels */
            labels: string[];
            /** @description List of errors encountered during the request */
            errors: string[];
        };
        /**
         * @deprecated
         * @description Deprecated response object for listing all labels
         */
        ListTagResponse: {
            /** @description List of unique labels */
            tags: string[];
            /** @description List of errors encountered during the request */
            errors: string[];
        };
        /** @description Response object for listing distributed workers */
        WorkersListResponse: {
            /** @description List of distributed workers */
            workers: components["schemas"]["Worker"][];
            /** @description List of errors encountered during the request */
            errors: string[];
        };
        /** @description Information about a distributed worker */
        Worker: {
            /** @description Unique identifier for the worker */
            id: string;
            /** @description Key-value pairs of labels assigned to the worker */
            labels: {
                [key: string]: string;
            };
            /** @description Total number of pollers configured for this worker */
            totalPollers: number;
            /** @description Number of pollers currently executing tasks */
            busyPollers: number;
            /** @description List of tasks currently being executed by this worker */
            runningTasks: components["schemas"]["RunningTask"][];
            /** @description RFC3339 timestamp of the last heartbeat received from this worker */
            lastHeartbeatAt: string;
            healthStatus: components["schemas"]["WorkerHealthStatus"];
        };
        /** @description Information about a task currently being executed */
        RunningTask: {
            dagRunId: components["schemas"]["DAGRunId"];
            dagName: components["schemas"]["DAGName"];
            /** @description RFC3339 timestamp when the task started */
            startedAt: string;
            rootDagRunName?: components["schemas"]["DAGName"];
            rootDagRunId?: components["schemas"]["DAGRunId"];
            parentDagRunName?: components["schemas"]["DAGName"];
            parentDagRunId?: components["schemas"]["DAGRunId"];
        };
        /** @description Response containing all queues with their active DAG-runs */
        QueuesResponse: {
            /** @description List of all queues with their running and queued DAG-runs */
            queues: components["schemas"]["Queue"][];
            summary: components["schemas"]["QueuesSummary"];
        };
        /** @description A queue/process group with summary statistics */
        Queue: {
            /** @description Name of the queue (global queue name or DAG name if no queue specified) */
            name: string;
            /**
             * @description Type of queue - 'global' if explicitly defined, 'dag-based' if using DAG name
             * @enum {string}
             */
            type: QueueType;
            /** @description Maximum number of concurrent runs allowed. For 'global' queues, this is the configured maxConcurrency. For 'dag-based' queues, this is always 1 (FIFO execution) */
            maxConcurrency?: number;
            /** @description Number of currently running DAG-runs */
            runningCount: number;
            /** @description Number of queued DAG-runs waiting to execute */
            queuedCount: number;
            /** @description List of currently running DAG-runs (bounded by maxConcurrency) */
            running: components["schemas"]["DAGRunSummary"][];
        };
        /** @description Forward-only paginated queued DAG-run response */
        QueuedDAGRunsPageResponse: {
            /** @description List of queued DAG-run summaries */
            items: components["schemas"]["DAGRunSummary"][];
            /** @description Opaque cursor for loading the next page of queued DAG-runs */
            nextCursor?: string;
        };
        /** @description Summary statistics across all queues */
        QueuesSummary: {
            /** @description Total number of active queues */
            totalQueues: number;
            /** @description Total DAG-runs currently executing */
            totalRunning: number;
            /** @description Total DAG-runs waiting in queues */
            totalQueued: number;
            /** @description Sum of all queue maxConcurrency values */
            totalCapacity: number;
            /**
             * Format: float
             * @description System-wide utilization (totalRunning / totalCapacity * 100)
             */
            utilizationPercentage: number;
        };
        ResourceHistory: {
            cpu?: components["schemas"]["MetricPoint"][];
            memory?: components["schemas"]["MetricPoint"][];
            disk?: components["schemas"]["MetricPoint"][];
            load?: components["schemas"]["MetricPoint"][];
            /**
             * Format: int64
             * @description Total physical memory in bytes
             */
            memoryTotalBytes?: number;
            /**
             * Format: int64
             * @description Used physical memory in bytes
             */
            memoryUsedBytes?: number;
            /**
             * Format: int64
             * @description Total disk space in bytes
             */
            diskTotalBytes?: number;
            /**
             * Format: int64
             * @description Used disk space in bytes
             */
            diskUsedBytes?: number;
        };
        MetricPoint: {
            /**
             * Format: int64
             * @description Unix timestamp
             */
            timestamp: number;
            /** Format: double */
            value: number;
        };
        /**
         * @description User role determining access permissions. admin: full access including user management, manager: DAG CRUD and execution with audit log access, developer: DAG CRUD and execution, operator: DAG execution only, viewer: read-only
         * @enum {string}
         */
        UserRole: UserRole;
        /** @description Workspace name. The reserved names all and default are not allowed. */
        WorkspaceName: string;
        /** @description Role granted for a specific workspace */
        WorkspaceGrant: {
            workspace: components["schemas"]["WorkspaceName"];
            role: components["schemas"]["UserRole"];
        };
        /** @description Workspace access policy. all=true grants the top-level role in every workspace. all=false requires explicit workspace grants and a top-level viewer role. */
        WorkspaceAccess: {
            /** @description Whether this identity can access all workspaces */
            all: boolean;
            /** @description Workspace-specific grants used when all=false */
            grants: components["schemas"]["WorkspaceGrant"][];
        };
        /** @description Request body for initial admin account setup */
        SetupRequest: {
            /** @description Admin username */
            username: string;
            /** @description Admin password */
            password: string;
        };
        /** @description Request body for user login */
        LoginRequest: {
            /** @description User's username */
            username: string;
            /** @description User's password */
            password: string;
        };
        /** @description Response containing authentication token */
        LoginResponse: {
            /** @description JWT authentication token */
            token: string;
            /**
             * Format: date-time
             * @description Token expiration timestamp
             */
            expiresAt: string;
            user: components["schemas"]["User"];
        };
        /** @description Request body for changing password */
        ChangePasswordRequest: {
            /** @description Current password for verification */
            currentPassword: string;
            /** @description New password to set */
            newPassword: string;
        };
        /** @description Request body for admin password reset */
        ResetPasswordRequest: {
            /** @description New password to set for the user */
            newPassword: string;
        };
        /** @description Request body for creating a new user */
        CreateUserRequest: {
            /** @description Unique username */
            username: string;
            /** @description User's password */
            password: string;
            role: components["schemas"]["UserRole"];
            workspaceAccess?: components["schemas"]["WorkspaceAccess"];
        };
        /** @description Request body for updating a user */
        UpdateUserRequest: {
            /** @description New username (must be unique) */
            username?: string;
            role?: components["schemas"]["UserRole"];
            workspaceAccess?: components["schemas"]["WorkspaceAccess"];
            /** @description Whether to disable the user account */
            isDisabled?: boolean;
        };
        /** @description User information */
        User: {
            /** @description Unique user identifier */
            id: string;
            /** @description User's username */
            username: string;
            role: components["schemas"]["UserRole"];
            workspaceAccess: components["schemas"]["WorkspaceAccess"];
            /**
             * @description Authentication provider (builtin or oidc)
             * @enum {string}
             */
            authProvider?: UserAuthProvider;
            /** @description Whether the user account is disabled */
            isDisabled?: boolean;
            /**
             * Format: date-time
             * @description Account creation timestamp
             */
            createdAt: string;
            /**
             * Format: date-time
             * @description Last update timestamp
             */
            updatedAt: string;
        };
        /** @description Response containing user information */
        UserResponse: {
            user: components["schemas"]["User"];
        };
        /** @description Response containing list of users */
        UsersListResponse: {
            users: components["schemas"]["User"][];
        };
        /** @description API key information */
        APIKey: {
            /** @description Unique identifier */
            id: string;
            /** @description Human-readable name */
            name: string;
            /** @description Purpose description */
            description?: string;
            role: components["schemas"]["UserRole"];
            workspaceAccess: components["schemas"]["WorkspaceAccess"];
            /** @description First 8 characters for identification */
            keyPrefix: string;
            /**
             * Format: date-time
             * @description Creation timestamp
             */
            createdAt: string;
            /**
             * Format: date-time
             * @description Last update timestamp
             */
            updatedAt: string;
            /** @description Creator user ID */
            createdBy: string;
            /**
             * Format: date-time
             * @description Last authentication timestamp
             */
            lastUsedAt?: string | null;
        };
        /** @description API key response */
        APIKeyResponse: {
            apiKey: components["schemas"]["APIKey"];
        };
        /** @description List of API keys */
        APIKeysListResponse: {
            apiKeys: components["schemas"]["APIKey"][];
        };
        /** @description Create API key request */
        CreateAPIKeyRequest: {
            /** @description Human-readable name */
            name: string;
            /** @description Purpose description */
            description?: string;
            role: components["schemas"]["UserRole"];
            workspaceAccess?: components["schemas"]["WorkspaceAccess"];
        };
        /** @description Create API key response */
        CreateAPIKeyResponse: {
            apiKey: components["schemas"]["APIKey"];
            /** @description Full key secret, only returned once */
            key: string;
        };
        /** @description Update API key request */
        UpdateAPIKeyRequest: {
            /** @description New name */
            name?: string;
            /** @description New description */
            description?: string;
            role?: components["schemas"]["UserRole"];
            workspaceAccess?: components["schemas"]["WorkspaceAccess"];
        };
        /** @description Generic success response */
        SuccessResponse: {
            /** @description Success message */
            message: string;
        };
        /**
         * @description Sync status of a DAG
         * @enum {string}
         */
        SyncStatus: SyncStatus;
        /**
         * @description Summary status for the sync badge
         * @enum {string}
         */
        SyncSummary: SyncSummary;
        /**
         * @description Type of sync item
         * @enum {string}
         */
        SyncItemKind: SyncItemKind;
        /** @description Sync state for a single item */
        SyncItem: {
            /** @description Stable item identifier (file path without extension) */
            itemId: string;
            /** @description Relative file path with extension */
            filePath: string;
            /** @description Display-friendly item name */
            displayName: string;
            status: components["schemas"]["SyncStatus"];
            kind: components["schemas"]["SyncItemKind"];
            /** @description Commit hash when last synced */
            baseCommit?: string;
            /** @description Content hash when last synced */
            lastSyncedHash?: string;
            /**
             * Format: date-time
             * @description When the DAG was last synced
             */
            lastSyncedAt?: string;
            /**
             * Format: date-time
             * @description When the DAG was last modified locally
             */
            modifiedAt?: string;
            /** @description Current local content hash */
            localHash?: string;
            /** @description Remote commit hash (for conflicts) */
            remoteCommit?: string;
            /** @description Author of the remote commit (for conflicts) */
            remoteAuthor?: string;
            /** @description Message of the remote commit (for conflicts) */
            remoteMessage?: string;
            /**
             * Format: date-time
             * @description When the conflict was detected
             */
            conflictDetectedAt?: string;
            /** @description Status before transitioning to missing */
            previousStatus?: components["schemas"]["SyncStatus"];
            /**
             * Format: date-time
             * @description When the file was first detected as missing
             */
            missingAt?: string;
        };
        /** @description Counts of DAGs in each sync status */
        SyncStatusCounts: {
            synced: number;
            modified: number;
            untracked: number;
            conflict: number;
            missing: number;
        };
        /** @description Overall Git sync status */
        SyncStatusResponse: {
            /** @description Whether Git sync is enabled */
            enabled: boolean;
            /** @description Repository URL */
            repository?: string;
            /** @description Branch being synced */
            branch?: string;
            summary: components["schemas"]["SyncSummary"];
            /**
             * Format: date-time
             * @description When the last sync occurred
             */
            lastSyncAt?: string;
            /** @description Commit hash of last sync */
            lastSyncCommit?: string;
            /** @description Status of last sync (success/error) */
            lastSyncStatus?: string;
            /** @description Error message from last failed sync */
            lastError?: string;
            /** @description Sync state for each item */
            items: components["schemas"]["SyncItem"][];
            counts: components["schemas"]["SyncStatusCounts"];
        };
        /** @description Error during sync operation */
        SyncError: {
            itemId?: string;
            message: string;
        };
        /** @description Diff between local and remote versions of a sync item */
        SyncItemDiffResponse: {
            /** @description The item identifier */
            itemId: string;
            /** @description Relative file path with extension */
            filePath: string;
            status: components["schemas"]["SyncStatus"];
            /** @description Current local file content */
            localContent: string;
            /** @description Content from remote repository */
            remoteContent?: string;
            /** @description Commit hash being compared against */
            remoteCommit?: string;
            /** @description Author of the remote commit */
            remoteAuthor?: string;
            /** @description Commit message of the remote version */
            remoteMessage?: string;
        };
        /** @description Result of a sync operation */
        SyncResultResponse: {
            success: boolean;
            message?: string;
            /** @description DAG IDs that were synced */
            synced?: string[];
            /** @description DAG IDs that were modified */
            modified?: string[];
            /** @description DAG IDs with conflicts */
            conflicts?: string[];
            errors?: components["schemas"]["SyncError"][];
            /** Format: date-time */
            timestamp: string;
        };
        /** @description Request to publish a DAG */
        SyncPublishRequest: {
            /** @description Commit message */
            message?: string;
            /**
             * @description Force publish even with conflicts
             * @default false
             */
            force: boolean;
        };
        /** @description Request to publish selected items */
        SyncPublishAllRequest: {
            /** @description Commit message */
            message?: string;
            /** @description Item IDs to publish. If omitted, all modified or untracked items are published. */
            itemIds?: string[];
        };
        /** @description Request to delete selected items */
        SyncDeleteBatchRequest: {
            /** @description Item IDs to delete */
            itemIds: string[];
            /** @description Commit message for the deletion */
            message?: string;
            /** @description Force delete items with local modifications or conflicts */
            force?: boolean;
        };
        /** @description Response when a conflict is detected */
        SyncConflictResponse: {
            itemId: string;
            remoteCommit?: string;
            remoteAuthor?: string;
            remoteMessage?: string;
            message: string;
        };
        /** @description Result of connection test */
        SyncConnectionTestResponse: {
            success: boolean;
            message?: string;
            error?: string;
        };
        /** @description Git authentication configuration */
        SyncAuthConfig: {
            /** @enum {string} */
            type: SyncAuthConfigType;
            /** @description Personal access token (write-only) */
            token?: string;
            /** @description Path to SSH private key */
            sshKeyPath?: string;
        };
        /** @description Auto-sync configuration */
        SyncAutoSyncConfig: {
            enabled: boolean;
            onStartup: boolean;
            /** @description Sync interval in seconds */
            interval: number;
        };
        /** @description Commit configuration */
        SyncCommitConfig: {
            authorName?: string;
            authorEmail?: string;
        };
        /** @description Git sync configuration */
        SyncConfigResponse: {
            enabled: boolean;
            repository?: string;
            branch?: string;
            path?: string;
            auth?: components["schemas"]["SyncAuthConfig"];
            autoSync?: components["schemas"]["SyncAutoSyncConfig"];
            pushEnabled?: boolean;
            commit?: components["schemas"]["SyncCommitConfig"];
        };
        /** @description Request to update Git sync configuration */
        SyncConfigUpdateRequest: {
            enabled?: boolean;
            repository?: string;
            branch?: string;
            path?: string;
            auth?: components["schemas"]["SyncAuthConfig"];
            autoSync?: components["schemas"]["SyncAutoSyncConfig"];
            pushEnabled?: boolean;
            commit?: components["schemas"]["SyncCommitConfig"];
        };
        /** @description AI Agent configuration */
        AgentConfigResponse: {
            /** @description Whether the AI agent is enabled */
            enabled?: boolean;
            /** @description ID of the default model */
            defaultModelId?: string;
            toolPolicy?: components["schemas"]["AgentToolPolicy"];
            /** @description ID of the currently selected soul */
            selectedSoulId?: string | null;
            webSearch?: components["schemas"]["AgentWebSearchConfig"];
            webTools?: components["schemas"]["AgentWebToolsConfig"];
        };
        /** @description Request to update AI agent configuration */
        UpdateAgentConfigRequest: {
            /** @description Whether the AI agent is enabled */
            enabled?: boolean;
            /** @description ID of the default model */
            defaultModelId?: string;
            toolPolicy?: components["schemas"]["AgentToolPolicy"];
            /** @description ID of the soul to select */
            selectedSoulId?: string | null;
            webSearch?: components["schemas"]["AgentWebSearchConfig"];
            webTools?: components["schemas"]["AgentWebToolsConfig"];
        };
        /** @description Global tool permission policy for AI agent sessions */
        AgentToolPolicy: {
            /** @description Per-tool enable/disable map */
            tools?: {
                [key: string]: boolean;
            };
            bash?: components["schemas"]["AgentBashPolicy"];
        };
        /** @description Granular command policy for the bash tool */
        AgentBashPolicy: {
            rules?: components["schemas"]["AgentBashRule"][];
            /**
             * @description Behavior when no rule matches a command segment
             * @enum {string}
             */
            defaultBehavior?: AgentBashPolicyDefaultBehavior;
            /**
             * @description Behavior when a command segment is denied
             * @enum {string}
             */
            denyBehavior?: AgentBashPolicyDenyBehavior;
        };
        AgentBashRule: {
            name?: string;
            /** @description Regex pattern matched against each shell command segment */
            pattern: string;
            /** @enum {string} */
            action: AgentBashRuleAction;
            /** @description Rule enabled state (default: true when omitted) */
            enabled?: boolean;
        };
        /** @description Provider-native web search configuration for agent sessions */
        AgentWebSearchConfig: {
            /** @description Whether provider-native web search is enabled */
            enabled?: boolean;
            /** @description Maximum number of search invocations per request */
            maxUses?: number;
        };
        /**
         * @description Backend provider for agent web tools
         * @enum {string}
         */
        AgentWebToolsBackend: AgentWebToolsBackend;
        /** @description First-class web_search and web_extract tool configuration */
        AgentWebToolsConfig: {
            /** @description Whether provider-backed web tools are enabled */
            enabled?: boolean;
            backend?: components["schemas"]["AgentWebToolsBackend"];
            tavily?: components["schemas"]["AgentTavilyWebToolsConfig"];
            firecrawl?: components["schemas"]["AgentFirecrawlWebToolsConfig"];
        };
        /** @description Tavily web tool settings */
        AgentTavilyWebToolsConfig: {
            /** @description Tavily API key. Write-only; omitted from responses. */
            apiKey?: string;
            /** @description Clear the stored Tavily API key when true */
            clearApiKey?: boolean;
            /** @description Whether a Tavily API key is stored */
            readonly apiKeyConfigured?: boolean;
            /**
             * Format: uri
             * @description Optional Tavily-compatible base URL
             */
            baseUrl?: string;
            /** @description Maximum search results allowed per web_search call */
            maxResults?: number;
            /**
             * @description Tavily search depth
             * @enum {string}
             */
            searchDepth?: AgentTavilyWebToolsConfigSearchDepth;
        };
        /** @description Firecrawl web tool settings */
        AgentFirecrawlWebToolsConfig: {
            /** @description Firecrawl API key. Write-only; omitted from responses. */
            apiKey?: string;
            /** @description Clear the stored Firecrawl API key when true */
            clearApiKey?: boolean;
            /** @description Whether a Firecrawl API key is stored */
            readonly apiKeyConfigured?: boolean;
            /**
             * Format: uri
             * @description Optional Firecrawl-compatible base URL
             */
            baseUrl?: string;
            /** @description Maximum search results allowed per web_search call */
            maxResults?: number;
        };
        /** @description Model configuration */
        ModelConfigResponse: {
            id: string;
            name: string;
            /** @enum {string} */
            provider: ModelConfigResponseProvider;
            model: string;
            apiKeyConfigured?: boolean;
            baseUrl?: string;
            contextWindow?: number;
            maxOutputTokens?: number;
            /** Format: double */
            inputCostPer1M?: number;
            /** Format: double */
            outputCostPer1M?: number;
            supportsThinking?: boolean;
            /** @enum {string} */
            thinkingEffort?: ModelConfigResponseThinkingEffort;
            description?: string;
        };
        /** @description Request to create a new model configuration */
        CreateModelConfigRequest: {
            /** @description Optional custom ID (auto-generated from name if omitted) */
            id?: string;
            name: string;
            /** @enum {string} */
            provider: CreateModelConfigRequestProvider;
            model: string;
            apiKey?: string;
            baseUrl?: string;
            contextWindow?: number;
            maxOutputTokens?: number;
            /** Format: double */
            inputCostPer1M?: number;
            /** Format: double */
            outputCostPer1M?: number;
            supportsThinking?: boolean;
            /** @enum {string} */
            thinkingEffort?: CreateModelConfigRequestThinkingEffort;
            description?: string;
        };
        /** @description Request to update a model configuration */
        UpdateModelConfigRequest: {
            name?: string;
            /** @enum {string} */
            provider?: UpdateModelConfigRequestProvider;
            model?: string;
            apiKey?: string;
            baseUrl?: string;
            contextWindow?: number;
            maxOutputTokens?: number;
            /** Format: double */
            inputCostPer1M?: number;
            /** Format: double */
            outputCostPer1M?: number;
            supportsThinking?: boolean;
            /** @enum {string} */
            thinkingEffort?: UpdateModelConfigRequestThinkingEffort;
            description?: string;
        };
        /** @description Request to set the default model */
        SetDefaultModelRequest: {
            /** @description Model ID to set as default */
            modelId: string;
        };
        /** @description Response after setting the default model */
        SetDefaultModelResponse: {
            defaultModelId?: string;
        };
        /** @description List of model configurations */
        ListModelsResponse: {
            models: components["schemas"]["ModelConfigResponse"][];
            defaultModelId?: string;
        };
        /** @description Connection status for one subscription-backed agent auth provider */
        AgentAuthProviderStatus: {
            id: string;
            name: string;
            connected: boolean;
            /** Format: date-time */
            expiresAt?: string;
            canRefresh?: boolean;
            accountId?: string;
        };
        /** @description List of subscription-backed auth providers */
        ListAgentAuthProvidersResponse: {
            providers: components["schemas"]["AgentAuthProviderStatus"][];
        };
        /** @description Manual OAuth login flow information */
        StartAgentAuthProviderLoginResponse: {
            flowId: string;
            authUrl: string;
            instructions?: string;
        };
        /** @description Complete a manual OAuth login flow */
        CompleteAgentAuthProviderLoginRequest: {
            flowId: string;
            /** Format: uri */
            redirectUrl?: string;
            code?: string;
        } | unknown | unknown;
        /** @description Updated provider status after login completion */
        CompleteAgentAuthProviderLoginResponse: {
            provider: components["schemas"]["AgentAuthProviderStatus"];
        };
        /** @description Soul (agent personality) configuration */
        SoulResponse: {
            id: string;
            name: string;
            description?: string;
            /** @description Markdown body content (identity definition) */
            content?: string;
        };
        /** @description List of souls */
        ListSoulsResponse: {
            souls: components["schemas"]["SoulResponse"][];
            pagination: components["schemas"]["Pagination"];
        };
        /** @description Request to create a new soul */
        CreateSoulRequest: {
            /** @description Optional custom ID (auto-generated from name if omitted) */
            id?: string;
            name: string;
            description?: string;
            /** @description Markdown body content (identity definition) */
            content: string;
        };
        /** @description Request to update a soul (partial update) */
        UpdateSoulRequest: {
            name?: string;
            description?: string;
            /** @description Markdown body content (identity definition) */
            content?: string;
        };
        /** @description Full document with content */
        DocResponse: {
            id: string;
            title: string;
            /** @description Short document description from YAML frontmatter */
            description: string;
            /** @description Workspace that owns this document. Omitted for default documents. */
            workspace?: string;
            /** @description Full file content including YAML frontmatter */
            content: string;
            /** @description Absolute file path of the document on disk */
            filePath?: string;
            /**
             * Format: date-time
             * @description RFC3339 timestamp when the document was created
             */
            createdAt?: string;
            /**
             * Format: date-time
             * @description RFC3339 timestamp when the document was last updated
             */
            updatedAt?: string;
        };
        /** @description Lightweight document metadata */
        DocMetadataResponse: {
            id: string;
            title: string;
            /** @description Short document description from YAML frontmatter */
            description: string;
            /** @description Workspace that owns this document. Omitted for default documents. */
            workspace?: string;
            /**
             * Format: date-time
             * @description Last modification time of the document file
             */
            modifiedAt?: string;
        };
        /** @description A file or directory node in the doc tree */
        DocTreeNodeResponse: {
            id: string;
            name: string;
            title?: string;
            /** @description Workspace that owns this node. Omitted for default nodes. */
            workspace?: string;
            /** @enum {string} */
            type: DocTreeNodeResponseType;
            children?: components["schemas"]["DocTreeNodeResponse"][];
            /**
             * Format: date-time
             * @description Last modification time. For files: file mtime. For directories: most recent descendant mtime.
             */
            modifiedAt?: string;
        };
        /** @description Paginated document list (tree or flat) */
        DocListResponse: {
            tree?: components["schemas"]["DocTreeNodeResponse"][];
            items?: components["schemas"]["DocMetadataResponse"][];
            pagination: components["schemas"]["Pagination"];
        };
        /** @description A search result for a single document */
        DocSearchResultItem: {
            id: string;
            title: string;
            /** @description Short document description from YAML frontmatter */
            description: string;
            /** @description Workspace that owns this document. Omitted for default documents. */
            workspace?: string;
            matches?: components["schemas"]["SearchMatchItem"][];
        };
        /** @description Search results */
        DocSearchResponse: {
            results: components["schemas"]["DocSearchResultItem"][];
        };
        /** @description Relative document path (without extension), e.g. runbooks/deploy-guide. Must not start with / or contain .. */
        DocPath: string;
        /** @description Request to create a new document */
        CreateDocRequest: {
            id: components["schemas"]["DocPath"];
            /** @description Full file content including optional YAML frontmatter */
            content: string;
        };
        /** @description Request to update document content */
        UpdateDocRequest: {
            /** @description Full file content including optional YAML frontmatter */
            content: string;
        };
        /** @description Request to rename/move a document or directory */
        RenameDocRequest: {
            newPath: components["schemas"]["DocPath"];
        };
        /** @description Request to delete multiple documents or directories */
        DocDeleteBatchRequest: {
            /** @description Document or directory paths to delete (max 100) */
            paths: components["schemas"]["DocPath"][];
        };
        DocDeleteBatchResponse: {
            /** @description Successfully deleted paths */
            deleted: string[];
            /** @description Paths that failed to delete with error details */
            failed: components["schemas"]["DocDeleteBatchFailedItem"][];
            /** @description Human-readable summary */
            message: string;
        };
        DocDeleteBatchFailedItem: {
            path: string;
            error: string;
        };
        /** @description Hardcoded model preset with metadata */
        ModelPreset: {
            name: string;
            /** @enum {string} */
            provider: ModelPresetProvider;
            model: string;
            contextWindow?: number;
            maxOutputTokens?: number;
            /** Format: double */
            inputCostPer1M?: number;
            /** Format: double */
            outputCostPer1M?: number;
            supportsThinking?: boolean;
            /** @enum {string} */
            thinkingEffort?: ModelPresetThinkingEffort;
            description?: string;
        };
        /** @description List of model presets */
        ListModelPresetsResponse: {
            presets: components["schemas"]["ModelPreset"][];
        };
        /** @description Agent memory overview */
        AgentMemoryResponse: {
            /** @description Content of global MEMORY.md */
            globalMemory?: string;
            /** @description List of DAG names that have memory files */
            dagMemories?: components["schemas"]["DAGName"][];
            /** @description Root memory directory path */
            memoryDir?: string;
        };
        /** @description DAG-specific memory content */
        AgentDAGMemoryResponse: {
            dagName: components["schemas"]["DAGName"];
            content: string;
        };
        /** @description Request to update memory content */
        UpdateAgentMemoryRequest: {
            /** @description New memory content (markdown) */
            content: string;
        };
        /** @description Metadata for a registered agent tool */
        AgentToolInfo: {
            name: string;
            label: string;
            description: string;
        };
        /** @description List of agent tool metadata */
        ListAgentToolsResponse: {
            tools: components["schemas"]["AgentToolInfo"][];
        };
        /** @description DAG reference for context-aware agent responses */
        AgentDAGContext: {
            /** @description DAG file path or name */
            dagFile: string;
            /** @description Specific run ID of the DAG */
            dagRunId?: string;
        };
        /** @description Request to send a chat message to the agent */
        AgentChatRequest: {
            /** @description User's input text */
            message: string;
            /** @description LLM model ID to use */
            model?: string;
            /** @description DAG references for context */
            dagContexts?: components["schemas"]["AgentDAGContext"][];
            /** @description Enable approval prompts for dangerous commands */
            safeMode?: boolean;
            /** @description Soul ID to use for this session (overrides default) */
            soulId?: string;
            /** @description Optional client-provided session ID (UUID v4) for idempotent creation. Only used by the create-session endpoint; ignored by the chat endpoint. */
            sessionId?: string;
        };
        /** @description Response after creating a new agent session */
        CreateAgentSessionResponse: {
            sessionId: string;
            status: string;
        };
        /** @description Agent chat session metadata */
        AgentSession: {
            id: string;
            userId?: string;
            dagName?: string;
            title?: string;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            parentSessionId?: string;
            delegateTask?: string;
        };
        /** @description Current processing state of an agent session */
        AgentSessionState: {
            sessionId: string;
            working: boolean;
            /** @description Whether the agent is waiting for user input */
            hasPendingPrompt?: boolean;
            model?: string;
            /**
             * Format: double
             * @description Total accumulated cost in USD
             */
            totalCost: number;
        };
        /** @description Agent session with its current state */
        AgentSessionWithState: components["schemas"]["AgentSessionState"] & {
            session: components["schemas"]["AgentSession"];
        };
        /** @description Paginated list of agent sessions */
        ListAgentSessionsResponse: {
            sessions: components["schemas"]["AgentSessionWithState"][];
            pagination: components["schemas"]["Pagination"];
            /** @description Opaque cursor for loading the next page of older sessions */
            nextCursor?: string;
        };
        /** @description Function call details in a tool call */
        AgentToolCallFunction: {
            name: string;
            arguments: string;
        };
        /** @description Tool call requested by the LLM */
        AgentToolCall: {
            id: string;
            type: string;
            function: components["schemas"]["AgentToolCallFunction"];
        };
        /** @description Result from a tool execution */
        AgentToolResult: {
            toolCallId: string;
            content: string;
            isError?: boolean;
        };
        /** @description Token usage statistics from LLM */
        AgentTokenUsage: {
            promptTokens?: number;
            completionTokens?: number;
            totalTokens?: number;
        };
        /** @description UI action to be performed */
        AgentUIAction: {
            type: string;
            path?: string;
        };
        /** @description Single option in a user prompt */
        AgentUserPromptOption: {
            id: string;
            label: string;
            description?: string;
        };
        /** @description Question from the agent requiring user response */
        AgentUserPrompt: {
            promptId: string;
            question: string;
            options?: components["schemas"]["AgentUserPromptOption"][];
            allowFreeText: boolean;
            freeTextPlaceholder?: string;
            multiSelect: boolean;
            /** @enum {string} */
            promptType?: AgentUserPromptPromptType;
            command?: string;
            workingDir?: string;
        };
        /** @description A message in an agent session */
        AgentMessage: {
            id: string;
            sessionId: string;
            /** @enum {string} */
            type: AgentMessageType;
            /** Format: int64 */
            sequenceId: number;
            content?: string;
            toolCalls?: components["schemas"]["AgentToolCall"][];
            toolResults?: components["schemas"]["AgentToolResult"][];
            usage?: components["schemas"]["AgentTokenUsage"];
            /** Format: double */
            cost?: number;
            /** Format: date-time */
            createdAt: string;
            uiAction?: components["schemas"]["AgentUIAction"];
            userPrompt?: components["schemas"]["AgentUserPrompt"];
            delegateIds?: string[];
        };
        /** @description Session details including messages and current state */
        AgentSessionDetailResponse: {
            messages: components["schemas"]["AgentMessage"][];
            session: components["schemas"]["AgentSession"];
            sessionState: components["schemas"]["AgentSessionState"];
            delegates?: components["schemas"]["AgentDelegateSnapshot"][];
        };
        /** @description Snapshot of a delegate sub-agent's lifecycle state */
        AgentDelegateSnapshot: {
            id: string;
            task: string;
            /** @enum {string} */
            status: AgentDelegateSnapshotStatus;
            /** Format: double */
            cost?: number;
        };
        /** @description User's response to an agent prompt */
        AgentUserPromptResponse: {
            promptId: string;
            selectedOptionIds?: string[];
            freeTextResponse?: string;
            cancelled?: boolean;
        };
        /** @description Simple status response */
        AgentStatusResponse: {
            status: string;
        };
        CreateRemoteNodeRequest: {
            /** @description Display name for the remote node */
            name: string;
            /** @description Optional description */
            description?: string;
            /** @description Base URL of the remote Dagu instance API */
            apiBaseUrl: string;
            /**
             * @description Authentication mode
             * @default none
             * @enum {string}
             */
            authType: CreateRemoteNodeRequestAuthType;
            /** @description Username for basic auth */
            basicAuthUsername?: string;
            /** @description Password for basic auth */
            basicAuthPassword?: string;
            /** @description Bearer token for token auth */
            authToken?: string;
            /**
             * @description Skip TLS certificate verification
             * @default false
             */
            skipTlsVerify: boolean;
        };
        UpdateRemoteNodeRequest: {
            name?: string;
            description?: string;
            apiBaseUrl?: string;
            /** @enum {string} */
            authType?: UpdateRemoteNodeRequestAuthType;
            basicAuthUsername?: string;
            basicAuthPassword?: string;
            authToken?: string;
            skipTlsVerify?: boolean;
        };
        RemoteNodeResponse: {
            id: string;
            name: string;
            description?: string;
            apiBaseUrl: string;
            /** @enum {string} */
            authType: RemoteNodeResponseAuthType;
            /** @description Whether credentials are configured (values are never returned) */
            hasCredentials?: boolean;
            skipTlsVerify?: boolean;
            /**
             * @description Where this node is defined
             * @enum {string}
             */
            source: RemoteNodeResponseSource;
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            updatedAt?: string;
        };
        RemoteNodeListResponse: {
            remoteNodes: components["schemas"]["RemoteNodeResponse"][];
        };
        TestRemoteNodeConnectionResponse: {
            success: boolean;
            message?: string;
            error?: string;
        };
        /** @enum {string} */
        SecretProviderType: SecretProviderType;
        /** @enum {string} */
        SecretStatus: SecretStatus;
        CreateSecretRequest: {
            /** @description Secret scope for management. Use global for workspace-less secrets or a workspace name. Omit for global. */
            workspace?: string;
            /** @description Secret ref used from DAG YAML, for example prod/db-password. */
            ref: string;
            description?: string;
            /** @enum {string} */
            providerType: CreateSecretRequestProviderType;
            /** @description Initial Dagu-managed value. Write-only; never returned by the API. */
            value?: string;
        };
        UpdateSecretRequest: {
            description?: string;
            providerConnectionId?: string;
            providerRef?: string;
        };
        WriteSecretVersionRequest: {
            value: string;
        };
        SecretResponse: {
            id: string;
            /** @description global for workspace-less secrets, otherwise the workspace name. */
            workspace: string;
            /** @description Secret ref used from DAG YAML, for example prod/db-password. */
            ref: string;
            description?: string;
            providerType: components["schemas"]["SecretProviderType"];
            providerConnectionId?: string;
            providerRef?: string;
            providerRefFingerprint?: string;
            currentVersion: number;
            status: components["schemas"]["SecretStatus"];
            hasValue: boolean;
            /** Format: date-time */
            createdAt: string;
            /** Format: date-time */
            updatedAt: string;
            /** Format: date-time */
            lastCheckedAt?: string;
            /** Format: date-time */
            lastResolvedAt?: string;
            /** Format: date-time */
            lastRotatedAt?: string;
        };
        SecretListResponse: {
            secrets: components["schemas"]["SecretResponse"][];
            total: number;
        };
        CreateWorkspaceRequest: {
            name: components["schemas"]["WorkspaceName"];
            description?: string;
        };
        UpdateWorkspaceRequest: {
            name?: components["schemas"]["WorkspaceName"];
            description?: string;
        };
        WorkspaceResponse: {
            id: string;
            name: components["schemas"]["WorkspaceName"];
            description?: string;
            /** Format: date-time */
            createdAt?: string;
            /** Format: date-time */
            updatedAt?: string;
        };
        WorkspaceListResponse: {
            workspaces: components["schemas"]["WorkspaceResponse"][];
        };
    };
    responses: never;
    parameters: {
        /** @description page number of items to fetch (default is 1) */
        Page: number;
        /** @description unique identifier of the user */
        UserId: string;
        /** @description unique identifier of the API key */
        APIKeyId: string;
        /** @description number of items per page (default is 30, max is 100) */
        PerPage: number;
        /** @description Opaque cursor for loading the next page of older agent sessions */
        AgentSessionCursor: string;
        /** @description Pagination mode. Use `cursor` for the agent session sidebar infinite-loading flow; omit or use `offset` for compatibility pagination. */
        AgentSessionPaginationMode: ComponentsParametersAgentSessionPaginationMode;
        /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
        Workspace: string;
        /** @description Opaque cursor returned by the previous search response */
        SearchCursor: string;
        /** @description Number of search results to return (default 20, max 50) */
        SearchLimit: number;
        /** @description Number of search match snippets to return (default 5, max 50) */
        SearchMatchLimit: number;
        /** @description the name of the DAG file */
        DAGFileName: components["schemas"]["DAGFileName"];
        /** @description name of the DAG */
        DAGName: components["schemas"]["DAGName"];
        /** @description name of the step */
        StepName: string;
        /** @description Relative artifact file path within the DAG-run artifact directory. Must not start with '/' or '\' or contain '..'. */
        ArtifactPath: string & unknown & unknown & unknown;
        /** @description Whether to recursively expand nested artifact directories */
        ArtifactRecursive: boolean;
        /** @description name of the remote node */
        RemoteNode: string;
        /** @description Filter entries after this time (ISO 8601 format) */
        LogStartTime: string;
        /** @description Filter entries before this time (ISO 8601 format) */
        LogEndTime: string;
        /** @description Maximum number of entries to return (default 100) */
        AuditLogLimit: number;
        /** @description Maximum number of entries to return (default 50) */
        EventLogLimit: number;
        /** @description Opaque cursor for loading older event log entries */
        EventLogCursor: string;
        /** @description Maximum number of DAG-runs to return (default 100) */
        DAGRunListLimit: number;
        /** @description Opaque cursor for loading the next page of older DAG-runs */
        DAGRunListCursor: string;
        /** @description Maximum number of queued DAG-runs to return (default 100) */
        QueueListLimit: number;
        /** @description Opaque cursor for loading the next page of queued DAG-runs */
        QueueListCursor: string;
        /** @description Pagination mode. Use `cursor` for the event feed infinite-loading flow; omit or use `offset` for compatibility pagination. */
        EventLogPaginationMode: ComponentsParametersEventLogPaginationMode;
        /** @description Number of entries to skip (for pagination) */
        LogOffset: number;
        /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
        DAGRunId: components["schemas"]["DAGRunId"];
        /** @description ID of the DAG-run; must not be the special 'latest' alias */
        DAGRunConcreteId: string & unknown;
        /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
        DAGRunIdSearch: components["schemas"]["DAGRunId"];
        /** @description name of the DAG-run */
        DAGRunName: string;
        /** @description status of the DAG-run. Repeat the parameter to match multiple statuses. */
        StatusList: components["schemas"]["Status"][];
        /** @description start datetime for filtering DAG-runs in ISO 8601 format with timezone */
        DateTimeFrom: components["schemas"]["UnixTimestamp"];
        /** @description end datetime for filtering DAG-runs in ISO 8601 format with timezone */
        DateTimeTo: components["schemas"]["UnixTimestamp"];
        /** @description Number of lines to return from the end of the file */
        Tail: number;
        /** @description Number of lines to return from the beginning of the file */
        Head: number;
        /** @description Line number to start reading from (1-based) */
        Offset: number;
        /** @description Maximum number of lines to return */
        Limit: number;
        /** @description Whether to return stdout or stderr logs */
        Stream: components["schemas"]["Stream"];
        /** @description Unique identifier of the agent session */
        AgentSessionId: string;
        /** @description The soul ID */
        SoulId: string;
        /** @description The unique identifier of the remote node */
        RemoteNodeId: string;
    };
    requestBodies: never;
    headers: never;
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    getHealthStatus: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["HealthResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
        };
    };
    getOpenapiJson: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description The OpenAPI document */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        [key: string]: unknown;
                    };
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    setup: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SetupRequest"];
            };
        };
        responses: {
            /** @description Admin account created successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["LoginResponse"];
                };
            };
            /** @description Invalid request (e.g., weak password) */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Setup already completed (users exist) */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    login: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["LoginRequest"];
            };
        };
        responses: {
            /** @description Authentication successful */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["LoginResponse"];
                };
            };
            /** @description Invalid credentials */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getCurrentUser: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Current user information */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["UserResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    changePassword: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ChangePasswordRequest"];
            };
        };
        responses: {
            /** @description Password changed successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SuccessResponse"];
                };
            };
            /** @description Invalid request (e.g., weak password) */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated or wrong current password */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listUsers: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of users */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["UsersListResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createUser: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateUserRequest"];
            };
        };
        responses: {
            /** @description User created successfully */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["UserResponse"];
                };
            };
            /** @description Invalid request (e.g., weak password, invalid role) */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Conflict - username already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description unique identifier of the user */
                userId: components["parameters"]["UserId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description User details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["UserResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description User not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description unique identifier of the user */
                userId: components["parameters"]["UserId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description User deleted successfully */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires admin role or cannot delete self */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description User not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateUser: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description unique identifier of the user */
                userId: components["parameters"]["UserId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateUserRequest"];
            };
        };
        responses: {
            /** @description User updated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["UserResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description User not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Conflict - username already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    resetUserPassword: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description unique identifier of the user */
                userId: components["parameters"]["UserId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["ResetPasswordRequest"];
            };
        };
        responses: {
            /** @description Password reset successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SuccessResponse"];
                };
            };
            /** @description Invalid request (e.g., weak password) */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description User not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listAPIKeys: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of API keys */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["APIKeysListResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createAPIKey: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateAPIKeyRequest"];
            };
        };
        responses: {
            /** @description Created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["CreateAPIKeyResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Name already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAPIKey: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description unique identifier of the API key */
                keyId: components["parameters"]["APIKeyId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description API key details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["APIKeyResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteAPIKey: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description unique identifier of the API key */
                keyId: components["parameters"]["APIKeyId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description API key deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateAPIKey: {
        parameters: {
            query?: never;
            header?: never;
            path: {
                /** @description unique identifier of the API key */
                keyId: components["parameters"]["APIKeyId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateAPIKeyRequest"];
            };
        };
        responses: {
            /** @description Updated API key */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["APIKeyResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Name already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getWorkers: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WorkersListResponse"];
                };
            };
            /** @description Coordinator service unavailable */
            503: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listDAGs: {
        parameters: {
            query?: {
                /** @description page number of items to fetch (default is 1) */
                page?: components["parameters"]["Page"];
                /** @description number of items per page (default is 30, max is 100) */
                perPage?: components["parameters"]["PerPage"];
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Filter DAGs by name */
                name?: string;
                /** @description Filter DAGs by labels (comma-separated). Returns DAGs that have ALL specified labels. Mutually exclusive with `tags`; the server returns HTTP 400 if both are set. */
                labels?: string;
                /**
                 * @deprecated
                 * @description Deprecated alias for `labels`; mutually exclusive with `labels`. Filter DAGs by labels (comma-separated).
                 */
                tags?: string;
                /** @description Field to sort by:
                 *     - `name`: Sort alphabetically by DAG name (case-insensitive)
                 *     - `nextRun`: Sort by next scheduled run time. DAGs with earlier next run times appear first in ascending order. DAGs without schedules appear last.
                 *      */
                sort?: PathsDagsGetParametersQuerySort;
                /** @description Sort order (ascending or descending) */
                order?: PathsDagsGetParametersQueryOrder;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of DAG definitions with their status and metadata */
                        dags: components["schemas"]["DAGFile"][];
                        /** @description List of errors encountered during the request */
                        errors: string[];
                        pagination: components["schemas"]["Pagination"];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createNewDAG: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    name: components["schemas"]["DAGName"];
                    /** @description Optional DAG spec in YAML format to initialize the DAG. If provided, the spec will be validated before creation. */
                    spec?: string;
                };
            };
        };
        responses: {
            /** @description A successful response */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Name of the newly created DAG */
                        name: string;
                    };
                };
            };
            /** @description Invalid DAG spec */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    validateDAGSpec: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description DAG specification in YAML format */
                    spec: string;
                    /** @description Optional name to use when the spec omits a name */
                    name?: string;
                };
            };
        };
        responses: {
            /** @description Validation result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description True if the spec is valid (no errors) */
                        valid: boolean;
                        dag?: components["schemas"]["DAGDetails"];
                        /** @description List of validation errors */
                        errors: string[];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGDetails: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Absolute file path of the DAG file on disk */
                        filePath?: string;
                        dag?: components["schemas"]["DAGDetails"];
                        /** @description List of local DAGs that are part of this DAG */
                        localDags: components["schemas"]["LocalDag"][];
                        latestDAGRun: components["schemas"]["DAGRunDetails"];
                        /** @description Whether the DAG is suspended */
                        suspended: boolean;
                        /** @description List of errors encountered during the request */
                        errors: string[];
                        /** @description The DAG specification in YAML format */
                        spec?: string;
                        editorHints?: components["schemas"]["DAGEditorHints"];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteDAG: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG successfully deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    executeDAG: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Parameters to pass to the DAG-run in JSON format */
                    params?: string;
                    dagRunId?: components["schemas"]["DAGRunId"] & unknown;
                    /** @description Optional DAG name override to use for the created dag-run */
                    dagName?: string;
                    /**
                     * @description If true, prevent starting if DAG is already running (returns 409 conflict)
                     * @default false
                     */
                    singleton?: boolean;
                    /** @description Additional labels to apply to the DAG-run. Mutually exclusive with `tags`; the server returns HTTP 400 if both are set. */
                    labels?: components["schemas"]["Labels"];
                    /** @description Deprecated alias for `labels`; mutually exclusive with `labels`. */
                    tags?: components["schemas"]["Tags"];
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunId: components["schemas"]["DAGRunId"];
                    };
                };
            };
            /** @description Invalid request parameters or labels */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG is already running (singleton mode) or dagRunId already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    executeDAGSync: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Parameters to pass to the DAG-run in JSON format */
                    params?: string;
                    dagRunId?: components["schemas"]["DAGRunId"] & unknown;
                    /** @description Optional DAG name override to use for the created dag-run */
                    dagName?: string;
                    /**
                     * @description If true, prevent starting if DAG is already running (returns 409 conflict)
                     * @default false
                     */
                    singleton?: boolean;
                    /** @description Additional labels to apply to the DAG-run. Mutually exclusive with `tags`; the server returns HTTP 400 if both are set. */
                    labels?: components["schemas"]["Labels"];
                    /** @description Deprecated alias for `labels`; mutually exclusive with `labels`. */
                    tags?: components["schemas"]["Tags"];
                    /** @description Maximum seconds to wait for DAG execution to complete (required) */
                    timeout: number;
                };
            };
        };
        responses: {
            /** @description DAG-run completed (or reached waiting status) */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRun: components["schemas"]["DAGRunDetails"];
                    };
                };
            };
            /** @description Invalid request parameters or labels */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Timeout waiting for DAG execution to complete. The DAG run continues executing in the background. */
            408: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TimeoutError"];
                };
            };
            /** @description DAG is already running (singleton mode) or dagRunId already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    enqueueDAGDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Parameters to pass to the DAG-run in JSON format */
                    params?: string;
                    dagRunId?: components["schemas"]["DAGRunId"] & unknown;
                    /** @description Optional DAG name override to use for the queued dag-run */
                    dagName?: string;
                    /** @description Override the DAG-level queue definition */
                    queue?: string;
                    /**
                     * @description If true, prevent enqueuing if DAG is already running or queued (returns 409 conflict)
                     * @default false
                     */
                    singleton?: boolean;
                    /** @description Additional labels to apply to the DAG-run. Mutually exclusive with `tags`; the server returns HTTP 400 if both are set. */
                    labels?: components["schemas"]["Labels"];
                    /** @description Deprecated alias for `labels`; mutually exclusive with `labels`. */
                    tags?: components["schemas"]["Tags"];
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunId: components["schemas"]["DAGRunId"];
                    };
                };
            };
            /** @description Invalid request parameters or labels */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG is already running or queued (singleton mode) */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGDAGRunHistory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of historical DAG-runs created from this DAG */
                        dagRuns: components["schemas"]["DAGRunDetails"][];
                        /** @description Grid data for visualization */
                        gridData: components["schemas"]["DAGGridItem"][];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGDAGRunDetails: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRun: components["schemas"]["DAGRunDetails"];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGSpec: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dag?: components["schemas"]["DAGDetails"];
                        /** @description The DAG spec in YAML format */
                        spec: string;
                        /** @description List of errors in the spec */
                        errors: string[];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateDAGSpec: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The new DAG spec in YAML format */
                    spec: string;
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of errors in the spec */
                        errors: string[];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateDAGSuspensionState: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Suspend status to set for the DAG */
                    suspend: boolean;
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    renameDAG: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description New file name for the DAG */
                    newFileName: string;
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    stopAllDAGRuns: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Successfully stopped all running instances */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Errors encountered */
                        errors: string[];
                    };
                };
            };
            /** @description DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    searchDAGs: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description A search query string */
                q: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Search results matching the query */
                        results: components["schemas"]["SearchResultItem"][];
                        /** @description Errors encountered during the search */
                        errors: string[];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    searchDAGFeed: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description A search query string */
                q: string;
                /** @description Filter DAGs by labels (comma-separated). Returns DAGs that have ALL specified labels. */
                labels?: string;
                /** @description Opaque cursor returned by the previous search response */
                cursor?: components["parameters"]["SearchCursor"];
                /** @description Number of search results to return (default 20, max 50) */
                limit?: components["parameters"]["SearchLimit"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Cursor-based DAG search results */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DAGSearchFeedResponse"];
                };
            };
            /** @description Invalid search request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    searchDocFeed: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description A search query string */
                q: string;
                /** @description Opaque cursor returned by the previous search response */
                cursor?: components["parameters"]["SearchCursor"];
                /** @description Number of search results to return (default 20, max 50) */
                limit?: components["parameters"]["SearchLimit"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Cursor-based document search results */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DocSearchFeedResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    searchDagMatches: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description A search query string */
                q: string;
                /** @description Filter DAG matches by labels (comma-separated). Returns matches only when the DAG has ALL specified labels. */
                labels?: string;
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Opaque cursor returned by the previous search response */
                cursor?: components["parameters"]["SearchCursor"];
                /** @description Number of search match snippets to return (default 5, max 50) */
                limit?: components["parameters"]["SearchMatchLimit"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Cursor-based DAG match snippets */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SearchMatchesResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    searchDocMatches: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Document path (may include slashes for nested docs) */
                path: components["schemas"]["DocPath"];
                /** @description A search query string */
                q: string;
                /** @description Opaque cursor returned by the previous search response */
                cursor?: components["parameters"]["SearchCursor"];
                /** @description Number of search match snippets to return (default 5, max 50) */
                limit?: components["parameters"]["SearchMatchLimit"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Cursor-based document match snippets */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SearchMatchesResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Document not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAllDAGLabels: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListLabelResponse"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAllDAGTags: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListTagResponse"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listDAGRuns: {
        parameters: {
            query?: {
                /** @description status of the DAG-run. Repeat the parameter to match multiple statuses. */
                status?: components["parameters"]["StatusList"];
                /** @description start datetime for filtering DAG-runs in ISO 8601 format with timezone */
                fromDate?: components["parameters"]["DateTimeFrom"];
                /** @description end datetime for filtering DAG-runs in ISO 8601 format with timezone */
                toDate?: components["parameters"]["DateTimeTo"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId?: components["parameters"]["DAGRunIdSearch"];
                /** @description Maximum number of DAG-runs to return (default 100) */
                limit?: components["parameters"]["DAGRunListLimit"];
                /** @description Opaque cursor for loading the next page of older DAG-runs */
                cursor?: components["parameters"]["DAGRunListCursor"];
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Filter DAG-runs by name */
                name?: string;
                /** @description Filter DAG-runs by DAG labels (comma-separated). Returns runs from DAGs that have ALL specified labels. Mutually exclusive with `tags`; the server returns HTTP 400 if both are set. */
                labels?: string;
                /**
                 * @deprecated
                 * @description Deprecated alias for `labels`; mutually exclusive with `labels`. Filter DAG-runs by DAG labels (comma-separated).
                 */
                tags?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DAGRunsPageResponse"];
                };
            };
            /** @description Malformed cursor or invalid pagination parameters */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    executeDAGRunFromSpec: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description DAG specification in YAML format */
                    spec: string;
                    /** @description Optional name to use when the spec omits a name */
                    name?: string;
                    /** @description Parameters to pass to the DAG-run in JSON format */
                    params?: string;
                    dagRunId?: components["schemas"]["DAGRunId"] & unknown;
                    /**
                     * @description If true, prevent starting if a DAG with the same name is already running (returns 409)
                     * @default false
                     */
                    singleton?: boolean;
                    /** @description Additional labels to apply to the DAG-run. Mutually exclusive with `tags`; the server returns HTTP 400 if both are set. */
                    labels?: components["schemas"]["Labels"];
                    /** @description Deprecated alias for `labels`; mutually exclusive with `labels`. */
                    tags?: components["schemas"]["Tags"];
                };
            };
        };
        responses: {
            /** @description Run created and started */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunId: components["schemas"]["DAGRunId"];
                    };
                };
            };
            /** @description Invalid DAG spec or parameters */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description A DAG with the same name is already running and singleton is enabled */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    enqueueDAGRunFromSpec: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description DAG specification in YAML format */
                    spec: string;
                    /** @description Optional name to use when the spec omits a name */
                    name?: string;
                    /** @description Parameters to persist with the queued DAG-run in JSON format */
                    params?: string;
                    dagRunId?: components["schemas"]["DAGRunId"] & unknown;
                    /** @description Override the queue to use for this DAG-run */
                    queue?: string;
                    /**
                     * @description If true, prevent enqueuing if DAG is already running or queued (returns 409 conflict)
                     * @default false
                     */
                    singleton?: boolean;
                    /** @description Additional labels to apply to the DAG-run. Mutually exclusive with `tags`; the server returns HTTP 400 if both are set. */
                    labels?: components["schemas"]["Labels"];
                    /** @description Deprecated alias for `labels`; mutually exclusive with `labels`. */
                    tags?: components["schemas"]["Tags"];
                };
            };
        };
        responses: {
            /** @description DAG-run successfully enqueued */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunId: components["schemas"]["DAGRunId"];
                    };
                };
            };
            /** @description Invalid DAG spec or parameters */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG is already running or queued (singleton mode), or dagRunId already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listDAGRunsByName: {
        parameters: {
            query?: {
                /** @description status of the DAG-run. Repeat the parameter to match multiple statuses. */
                status?: components["parameters"]["StatusList"];
                /** @description start datetime for filtering DAG-runs in ISO 8601 format with timezone */
                fromDate?: components["parameters"]["DateTimeFrom"];
                /** @description end datetime for filtering DAG-runs in ISO 8601 format with timezone */
                toDate?: components["parameters"]["DateTimeTo"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId?: components["parameters"]["DAGRunIdSearch"];
                /** @description Maximum number of DAG-runs to return (default 100) */
                limit?: components["parameters"]["DAGRunListLimit"];
                /** @description Opaque cursor for loading the next page of older DAG-runs */
                cursor?: components["parameters"]["DAGRunListCursor"];
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
            };
            header?: never;
            path: {
                /** @description name of the DAG-run */
                name: components["parameters"]["DAGRunName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DAGRunsPageResponse"];
                };
            };
            /** @description Malformed cursor or invalid pagination parameters */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunDetails: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunDetails: components["schemas"]["DAGRunDetails"];
                    };
                };
            };
            /** @description DAGRun not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run; must not be the special 'latest' alias */
                dagRunId: components["parameters"]["DAGRunConcreteId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG-run successfully deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description DAG-run cannot be deleted */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG-run not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunSpec: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The DAG spec in YAML format */
                        spec: string;
                    };
                };
            };
            /** @description DAG-run or DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    rescheduleDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    dagRunId?: components["schemas"]["DAGRunId"] & unknown;
                    /** @description Optional DAG name override for the new run. */
                    dagName?: string;
                    /** @description When true, reschedule from the current contents of the original DAG file instead of the stored historical YAML snapshot. */
                    useCurrentDagFile?: boolean;
                };
            };
        };
        responses: {
            /** @description Successfully scheduled a new DAG-run */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunId: components["schemas"]["DAGRunId"];
                        /** @description Indicates whether the run was queued instead of starting immediately. */
                        queued: boolean;
                    };
                };
            };
            /** @description Invalid request parameters */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Historic run not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Conflict (run ID already exists) */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    previewEditRetryDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Edited DAG specification in YAML format. */
                    spec: string;
                    /** @description Optional DAG name override for the edited retry run. */
                    dagName?: string;
                };
            };
        };
        responses: {
            /** @description Successfully previewed the edited retry */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Resolved DAG name for the edited retry. */
                        dagName: string;
                        /** @description Default steps selected to be skipped. */
                        skippedSteps: string[];
                        /** @description Steps that will be started if not skipped. */
                        runnableSteps: string[];
                        /** @description Resolved edited DAG steps in execution order for preview rendering. */
                        steps: components["schemas"]["Step"][];
                        /** @description Previous completed steps that cannot be skipped with the edited specification. */
                        ineligibleSteps: {
                            stepName: string;
                            reason: string;
                        }[];
                        /** @description Validation errors that must be fixed before launching. */
                        errors: string[];
                        /** @description Non-blocking warnings for the edited retry. */
                        warnings: string[];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    editRetryDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Edited DAG specification in YAML format. */
                    spec: string;
                    dagRunId?: components["schemas"]["DAGRunCreateId"] & unknown;
                    /** @description Optional DAG name override for the edited retry run. */
                    dagName?: string;
                    /** @description Steps to mark skipped while preserving their previous output variables. */
                    skipSteps?: string[];
                };
            };
        };
        responses: {
            /** @description Successfully launched edited retry */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunId: components["schemas"]["DAGRunId"];
                        /** @description Indicates whether the run was queued instead of starting immediately. */
                        queued: boolean;
                        skippedSteps: string[];
                        startedSteps: string[];
                    };
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRuns: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Optional parent sub DAG run ID. When provided, returns sub-runs of this specific sub DAG run instead of the root DAG run. Used for multi-level nested DAGs. */
                parentSubDAGRunId?: string;
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        subRuns: components["schemas"]["SubDAGRunDetail"][];
                    };
                };
            };
            /** @description DAG run not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    dequeueDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description DAGRun not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Number of lines to return from the end of the file */
                tail?: components["parameters"]["Tail"];
                /** @description Number of lines to return from the beginning of the file */
                head?: components["parameters"]["Head"];
                /** @description Line number to start reading from (1-based) */
                offset?: components["parameters"]["Offset"];
                /** @description Maximum number of lines to return */
                limit?: components["parameters"]["Limit"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Log"];
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    downloadDAGRunLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Log file content */
            200: {
                headers: {
                    /** @description Attachment filename */
                    "Content-Disposition"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunArtifacts: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Whether to recursively expand nested artifact directories */
                recursive?: components["parameters"]["ArtifactRecursive"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact tree retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ArtifactTreeResponse"];
                };
            };
            /** @description Artifact directory not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunArtifactPreview: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Relative artifact file path within the DAG-run artifact directory. Must not start with '/' or '\' or contain '..'. */
                path: components["parameters"]["ArtifactPath"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact preview retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ArtifactPreviewResponse"];
                };
            };
            /** @description Artifact file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    downloadDAGRunArtifact: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Relative artifact file path within the DAG-run artifact directory. Must not start with '/' or '\' or contain '..'. */
                path: components["parameters"]["ArtifactPath"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact file content */
            200: {
                headers: {
                    /** @description Attachment filename */
                    "Content-Disposition"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/octet-stream": string;
                };
            };
            /** @description Artifact file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunOutputs: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Successfully retrieved outputs. Returns the collected outputs with metadata. If the DAG-run completed but captured no outputs, returns an empty outputs object. */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DAGRunOutputs"];
                };
            };
            /** @description DAG-run not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    retryDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    dagRunId: components["schemas"]["DAGRunId"] & unknown;
                    /** @description Optional. If provided, only this step will be retried. */
                    stepName?: string;
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    terminateDAGRun: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunStepLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Number of lines to return from the end of the file */
                tail?: components["parameters"]["Tail"];
                /** @description Number of lines to return from the beginning of the file */
                head?: components["parameters"]["Head"];
                /** @description Line number to start reading from (1-based) */
                offset?: components["parameters"]["Offset"];
                /** @description Maximum number of lines to return */
                limit?: components["parameters"]["Limit"];
                /** @description Whether to return stdout or stderr logs */
                stream?: components["parameters"]["Stream"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Log"];
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    downloadDAGRunStepLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Whether to return stdout or stderr logs */
                stream?: components["parameters"]["Stream"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Log file content */
            200: {
                headers: {
                    /** @description Attachment filename */
                    "Content-Disposition"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGRunStepMessages: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Chat messages retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ChatMessagesResponse"];
                };
            };
            /** @description DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateDAGRunStepStatus: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    status: components["schemas"]["NodeStatus"];
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAGRun or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    approveDAGRunStep: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["ApproveStepRequest"];
            };
        };
        responses: {
            /** @description Step approved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ApproveStepResponse"];
                };
            };
            /** @description Step is not in Waiting status or required inputs missing */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    rejectDAGRunStep: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RejectStepRequest"];
            };
        };
        responses: {
            /** @description Step rejected successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["RejectStepResponse"];
                };
            };
            /** @description Step is not in Waiting status */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    pushBackDAGRunStep: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["PushBackStepRequest"];
            };
        };
        responses: {
            /** @description Step pushed back successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PushBackStepResponse"];
                };
            };
            /** @description Step is not in Waiting status, missing required inputs, or step does not have approval config */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRunDetails: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to retrieve details for */
                subDAGRunId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dagRunDetails: components["schemas"]["DAGRunDetails"];
                    };
                };
            };
            /** @description Sub DAG-run not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRunSpec: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to retrieve the spec for */
                subDAGRunId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Sub-DAG specification retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description YAML specification of the sub-DAG */
                        spec: string;
                    };
                };
            };
            /** @description Sub-DAG run not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRunLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Number of lines to return from the end of the file */
                tail?: components["parameters"]["Tail"];
                /** @description Number of lines to return from the beginning of the file */
                head?: components["parameters"]["Head"];
                /** @description Line number to start reading from (1-based) */
                offset?: components["parameters"]["Offset"];
                /** @description Maximum number of lines to return */
                limit?: components["parameters"]["Limit"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to retrieve the log for */
                subDAGRunId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Log"];
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    downloadSubDAGRunLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to download the log for */
                subDAGRunId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Log file content */
            200: {
                headers: {
                    /** @description Attachment filename */
                    "Content-Disposition"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRunArtifacts: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Whether to recursively expand nested artifact directories */
                recursive?: components["parameters"]["ArtifactRecursive"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to retrieve artifacts for */
                subDAGRunId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact tree retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ArtifactTreeResponse"];
                };
            };
            /** @description Artifact directory not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRunArtifactPreview: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Relative artifact file path within the DAG-run artifact directory. Must not start with '/' or '\' or contain '..'. */
                path: components["parameters"]["ArtifactPath"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to preview an artifact for */
                subDAGRunId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact preview retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ArtifactPreviewResponse"];
                };
            };
            /** @description Artifact file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    downloadSubDAGRunArtifact: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Relative artifact file path within the DAG-run artifact directory. Must not start with '/' or '\' or contain '..'. */
                path: components["parameters"]["ArtifactPath"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to download an artifact for */
                subDAGRunId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Artifact file content */
            200: {
                headers: {
                    /** @description Attachment filename */
                    "Content-Disposition"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "application/octet-stream": string;
                };
            };
            /** @description Artifact file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRunStepLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Number of lines to return from the end of the file */
                tail?: components["parameters"]["Tail"];
                /** @description Number of lines to return from the beginning of the file */
                head?: components["parameters"]["Head"];
                /** @description Line number to start reading from (1-based) */
                offset?: components["parameters"]["Offset"];
                /** @description Maximum number of lines to return */
                limit?: components["parameters"]["Limit"];
                /** @description Whether to return stdout or stderr logs */
                stream?: components["parameters"]["Stream"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to retrieve the log for */
                subDAGRunId: string;
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Log"];
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    downloadSubDAGRunStepLog: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Whether to return stdout or stderr logs */
                stream?: components["parameters"]["Stream"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to download the step log for */
                subDAGRunId: string;
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Log file content */
            200: {
                headers: {
                    /** @description Attachment filename */
                    "Content-Disposition"?: string;
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Log file not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSubDAGRunStepMessages: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run */
                subDAGRunId: string;
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Chat messages retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ChatMessagesResponse"];
                };
            };
            /** @description Sub DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateSubDAGRunStepStatus: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run to update the step status for */
                subDAGRunId: string;
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    status: components["schemas"]["NodeStatus"];
                };
            };
        };
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAGRun or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    approveSubDAGRunStep: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run containing the step to approve */
                subDAGRunId: string;
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["ApproveStepRequest"];
            };
        };
        responses: {
            /** @description Step approved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ApproveStepResponse"];
                };
            };
            /** @description Step is not in Waiting status or required inputs missing */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Sub DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    rejectSubDAGRunStep: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run containing the step to reject */
                subDAGRunId: string;
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RejectStepRequest"];
            };
        };
        responses: {
            /** @description Step rejected successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["RejectStepResponse"];
                };
            };
            /** @description Step is not in Waiting status */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Sub DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    pushBackSubDAGRunStep: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description name of the DAG */
                name: components["parameters"]["DAGName"];
                /** @description ID of the DAG-run or 'latest' to get the most recent DAG-run */
                dagRunId: components["parameters"]["DAGRunId"];
                /** @description ID of the sub DAG-run containing the step to push back */
                subDAGRunId: string;
                /** @description name of the step */
                stepName: components["parameters"]["StepName"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["PushBackStepRequest"];
            };
        };
        responses: {
            /** @description Step pushed back successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["PushBackStepResponse"];
                };
            };
            /** @description Step is not in Waiting status, missing required inputs, or step does not have approval config */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Sub DAG-run or step not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listQueues: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["QueuesResponse"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getQueue: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Queue name */
                name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Queue"];
                };
            };
            /** @description Queue not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listQueueItems: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Maximum number of queued DAG-runs to return (default 100) */
                limit?: components["parameters"]["QueueListLimit"];
                /** @description Opaque cursor for loading the next page of queued DAG-runs */
                cursor?: components["parameters"]["QueueListCursor"];
            };
            header?: never;
            path: {
                /** @description Queue name */
                name: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["QueuedDAGRunsPageResponse"];
                };
            };
            /** @description Invalid cursor */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getResourceHistory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Duration of history to retrieve (e.g., 30m, 1h) */
                duration?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ResourceHistory"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSchedulerStatus: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SchedulerStatusResponse"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getCoordinatorStatus: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["CoordinatorStatusResponse"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getTunnelStatus: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description A successful response */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TunnelStatusResponse"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getMetrics: {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Prometheus metrics in text format */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "text/plain": string;
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    triggerWebhook: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: {
                /** @description Bearer token for webhook authentication (e.g., 'Bearer dagu_wh_...'). Required only when the webhook auth mode includes token authentication. */
                Authorization?: string;
                /** @description HMAC webhook signature in the format 'sha256=<hex>'. Required only when the webhook auth mode includes HMAC authentication with strict enforcement. */
                "X-Dagu-Signature"?: string;
            };
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["WebhookRequest"];
            };
        };
        responses: {
            /** @description DAG run triggered successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookResponse"];
                };
            };
            /** @description Invalid request body */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unauthorized - missing or invalid token, or invalid/missing X-Dagu-Signature when strict HMAC enforcement is active */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - webhook disabled or not configured */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG or webhook not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Conflict - DAG run with the specified dagRunId already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listWebhooks: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of webhooks */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookListResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getNotificationSettings: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Workspace notification settings */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationWorkspaceSettings"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateNotificationSettings: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["NotificationWorkspaceSettingsInput"];
            };
        };
        responses: {
            /** @description Workspace notification settings updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationWorkspaceSettings"];
                };
            };
            /** @description Invalid notification settings */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listNotificationRoutes: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of notification route sets */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationRouteSetListResponse"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getGlobalNotificationRoutes: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Global notification route set */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationRouteSet"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateGlobalNotificationRoutes: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["NotificationRouteSetInput"];
            };
        };
        responses: {
            /** @description Global notification route set updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationRouteSet"];
                };
            };
            /** @description Invalid notification route set */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Referenced notification channel was not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getWorkspaceNotificationRoutes: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceName: components["schemas"]["WorkspaceName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Workspace notification route set */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationRouteSet"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Workspace was not found or is not visible */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateWorkspaceNotificationRoutes: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceName: components["schemas"]["WorkspaceName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["NotificationRouteSetInput"];
            };
        };
        responses: {
            /** @description Workspace notification route set updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationRouteSet"];
                };
            };
            /** @description Invalid notification route set */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Workspace or referenced notification channel was not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listNotificationChannels: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of notification channels */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationChannelListResponse"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createNotificationChannel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["NotificationChannelInput"];
            };
        };
        responses: {
            /** @description Notification channel created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationChannel"];
                };
            };
            /** @description Invalid notification channel */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getNotificationChannel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                channelId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Notification channel */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationChannel"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Notification channel not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateNotificationChannel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                channelId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["NotificationChannelInput"];
            };
        };
        responses: {
            /** @description Notification channel updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["NotificationChannel"];
                };
            };
            /** @description Invalid notification channel */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Notification channel not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteNotificationChannel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                channelId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Notification channel deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Notification channel not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Notification channel is used by a DAG */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listIncidentProviders: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of incident providers */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentProviderListResponse"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createIncidentProvider: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["IncidentProviderInput"];
            };
        };
        responses: {
            /** @description Incident provider created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentProvider"];
                };
            };
            /** @description Invalid incident provider */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getIncidentProvider: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                providerId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Incident provider */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentProvider"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Incident provider not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateIncidentProvider: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                providerId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["IncidentProviderInput"];
            };
        };
        responses: {
            /** @description Incident provider updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentProvider"];
                };
            };
            /** @description Invalid incident provider */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Incident provider not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteIncidentProvider: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                providerId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Incident provider deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Incident provider not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Incident provider is used by routing */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    testIncidentProvider: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                providerId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Test incident delivery attempted */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TestIncidentProviderResponse"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Incident provider not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listIncidentPolicies: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of incident routing scopes */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentPolicySetListResponse"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getGlobalIncidentPolicies: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Global incident routing */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentPolicySet"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateGlobalIncidentPolicies: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["IncidentPolicySetInput"];
            };
        };
        responses: {
            /** @description Global incident routing updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentPolicySet"];
                };
            };
            /** @description Invalid incident routing */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Referenced incident provider was not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getWorkspaceIncidentPolicies: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceName: components["schemas"]["WorkspaceName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Workspace incident routing */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentPolicySet"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Workspace was not found or is not visible */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateWorkspaceIncidentPolicies: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceName: components["schemas"]["WorkspaceName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["IncidentPolicySetInput"];
            };
        };
        responses: {
            /** @description Workspace incident routing updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentPolicySet"];
                };
            };
            /** @description Invalid incident routing */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Workspace or referenced incident provider was not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGWebhook: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Webhook configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookDetails"];
                };
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createDAGWebhook: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Webhook created successfully */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookCreateResponse"];
                };
            };
            /** @description Webhook already exists for this DAG */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteDAGWebhook: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Webhook deleted successfully */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    regenerateDAGWebhookToken: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Token regenerated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookCreateResponse"];
                };
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    toggleDAGWebhook: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["WebhookToggleRequest"];
            };
        };
        responses: {
            /** @description Webhook toggled successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookDetails"];
                };
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    enableDAGWebhookHMAC: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["WebhookHMACConfigureRequest"];
            };
        };
        responses: {
            /** @description Webhook HMAC enabled successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookHMACSecretResponse"];
                };
            };
            /** @description Invalid request or invalid HMAC configuration */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Webhook HMAC is not supported on this node */
            501: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    configureDAGWebhookHMAC: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["WebhookHMACConfigureRequest"];
            };
        };
        responses: {
            /** @description Webhook HMAC updated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookDetails"];
                };
            };
            /** @description Invalid request or invalid HMAC configuration */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Webhook HMAC is not supported on this node */
            501: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    regenerateDAGWebhookHMACSecret: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Webhook HMAC secret regenerated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookHMACSecretResponse"];
                };
            };
            /** @description Webhook HMAC is not configured */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Webhook HMAC is not supported on this node */
            501: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    disableDAGWebhookHMAC: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Webhook HMAC disabled successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WebhookDetails"];
                };
            };
            /** @description No webhook configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Webhook HMAC is not supported on this node */
            501: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGNotifications: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG notification settings */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DAGNotificationSettings"];
                };
            };
            /** @description No notification settings configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateDAGNotifications: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateDAGNotificationsRequest"];
            };
        };
        responses: {
            /** @description DAG notification settings updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DAGNotificationSettings"];
                };
            };
            /** @description Invalid notification settings */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - notification channels require an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteDAGNotifications: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG notification settings deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description No notification settings configured for this DAG */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    testDAGNotifications: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["TestDAGNotificationRequest"];
            };
        };
        responses: {
            /** @description Test notification delivery attempted */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TestDAGNotificationResponse"];
                };
            };
            /** @description Invalid test notification request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG or target not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDAGIncidents: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG incident routing */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentPolicySet"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateDAGIncidents: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["IncidentPolicySetInput"];
            };
        };
        responses: {
            /** @description DAG incident routing updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["IncidentPolicySet"];
                };
            };
            /** @description Invalid incident routing */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG or referenced incident provider was not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteDAGIncidents: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description the name of the DAG file */
                fileName: components["parameters"]["DAGFileName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG incident routing deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Forbidden - requires an active Dagu license or trial */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description DAG incident policies not configured */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listAuditLogs: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Filter by audit category (e.g., terminal, user, dag) */
                category?: string;
                /** @description Filter by user ID */
                userId?: string;
                /** @description Filter entries after this time (ISO 8601 format) */
                startTime?: components["parameters"]["LogStartTime"];
                /** @description Filter entries before this time (ISO 8601 format) */
                endTime?: components["parameters"]["LogEndTime"];
                /** @description Maximum number of entries to return (default 100) */
                limit?: components["parameters"]["AuditLogLimit"];
                /** @description Number of entries to skip (for pagination) */
                offset?: components["parameters"]["LogOffset"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of audit log entries */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AuditLogsResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires manager or admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listEventLogs: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Filter by event kind (e.g., dag_run, llm_usage) */
                kind?: string;
                /** @description Filter by event type (e.g., dag.run.failed, llm.usage.recorded) */
                type?: string;
                /** @description Filter by DAG name */
                dagName?: string;
                /** @description Filter by DAG run ID */
                dagRunId?: string;
                /** @description Filter by attempt ID */
                attemptId?: string;
                /** @description Filter by session ID */
                sessionId?: string;
                /** @description Filter by user ID */
                userId?: string;
                /** @description Filter by model name */
                model?: string;
                /** @description Filter entries after this time (ISO 8601 format) */
                startTime?: components["parameters"]["LogStartTime"];
                /** @description Filter entries before this time (ISO 8601 format) */
                endTime?: components["parameters"]["LogEndTime"];
                /** @description Maximum number of entries to return (default 50) */
                limit?: components["parameters"]["EventLogLimit"];
                /** @description Pagination mode. Use `cursor` for the event feed infinite-loading flow; omit or use `offset` for compatibility pagination. */
                paginationMode?: components["parameters"]["EventLogPaginationMode"];
                /** @description Number of entries to skip (for pagination) */
                offset?: components["parameters"]["LogOffset"];
                /** @description Opaque cursor for loading older event log entries */
                cursor?: components["parameters"]["EventLogCursor"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of event log entries */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["EventLogsResponse"];
                };
            };
            /** @description Malformed cursor or invalid pagination parameters */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Forbidden - requires manager or admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSyncStatus: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Sync status retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncStatusResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    syncPull: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Pull completed successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncResultResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    syncPublishAll: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SyncPublishAllRequest"];
            };
        };
        responses: {
            /** @description Publish completed successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncResultResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    syncTestConnection: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Connection test result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncConnectionTestResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSyncConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Configuration retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncConfigResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateSyncConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SyncConfigUpdateRequest"];
            };
        };
        responses: {
            /** @description Configuration updated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncConfigResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSyncItemDiff: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The sync item identifier (file path without extension) */
                itemId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Diff retrieved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncItemDiffResponse"];
                };
            };
            /** @description Item not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    publishSyncItem: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The sync item identifier (file path without extension) */
                itemId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SyncPublishRequest"];
            };
        };
        responses: {
            /** @description Item published successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncResultResponse"];
                };
            };
            /** @description Item not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Conflict detected */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncConflictResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    discardSyncItemChanges: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The sync item identifier (file path without extension) */
                itemId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Changes discarded successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SuccessResponse"];
                };
            };
            /** @description Item not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    forgetSyncItem: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The sync item identifier (file path without extension) */
                itemId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Item forgotten successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SuccessResponse"];
                };
            };
            /** @description Item cannot be forgotten */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Item not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteSyncItem: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The sync item identifier (file path without extension) */
                itemId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Commit message for the deletion */
                    message?: string;
                    /** @description Force delete even if item has local modifications */
                    force?: boolean;
                };
            };
        };
        responses: {
            /** @description Item deleted successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SuccessResponse"];
                };
            };
            /** @description Item cannot be deleted */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Item not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    moveSyncItem: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The current sync item identifier (file path without extension) */
                itemId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The new item identifier to rename to */
                    newItemId: string;
                    /** @description Commit message for the move */
                    message?: string;
                    /** @description Force move even if item has conflicts */
                    force?: boolean;
                };
            };
        };
        responses: {
            /** @description Item moved successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SuccessResponse"];
                };
            };
            /** @description Item cannot be moved */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Item not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Conflict detected */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SyncConflictResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    syncDeleteMissing: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description Commit message for the deletion */
                    message?: string;
                };
            };
        };
        responses: {
            /** @description Missing items deleted successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of deleted item IDs */
                        deleted: string[];
                        /** @description Summary message */
                        message: string;
                    };
                };
            };
            /** @description Cannot delete */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    syncDeleteBatch: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SyncDeleteBatchRequest"];
            };
        };
        responses: {
            /** @description Items deleted successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of deleted item IDs */
                        deleted: string[];
                        /** @description Summary message */
                        message: string;
                    };
                };
            };
            /** @description Cannot delete (push disabled, untracked items, validation error) */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Item not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    syncCleanup: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Cleanup completed successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of forgotten item IDs */
                        forgotten: string[];
                        /** @description Summary message */
                        message: string;
                    };
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getBaseConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Base configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The base configuration in YAML format */
                        spec: string;
                        /** @description List of validation errors in the configuration */
                        errors: string[];
                    };
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires developer role or above */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateBaseConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The base configuration in YAML format */
                    spec: string;
                };
            };
        };
        responses: {
            /** @description Base configuration updated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of validation warnings */
                        errors: string[];
                    };
                };
            };
            /** @description Invalid configuration */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires developer role or above */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getWorkspaceBaseConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceName: components["schemas"]["WorkspaceName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Workspace base configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The workspace base configuration in YAML format */
                        spec: string;
                        /** @description List of validation errors in the configuration */
                        errors: string[];
                    };
                };
            };
            /** @description Invalid workspace */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Insufficient permissions */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Workspace not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateWorkspaceBaseConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceName: components["schemas"]["WorkspaceName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description The workspace base configuration in YAML format */
                    spec: string;
                };
            };
        };
        responses: {
            /** @description Workspace base configuration updated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description List of validation warnings */
                        errors: string[];
                    };
                };
            };
            /** @description Invalid configuration */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Insufficient permissions */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Workspace not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAgentConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Agent configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentConfigResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateAgentConfig: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateAgentConfigRequest"];
            };
        };
        responses: {
            /** @description Updated agent configuration */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentConfigResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listAgentModels: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of models */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListModelsResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createAgentModel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateModelConfigRequest"];
            };
        };
        responses: {
            /** @description Model created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ModelConfigResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Model already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listAgentAuthProviders: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of auth providers */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListAgentAuthProvidersResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    startAgentAuthProviderLogin: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Auth provider ID */
                providerId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Login flow started */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["StartAgentAuthProviderLoginResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    disconnectAgentAuthProviderLogin: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Auth provider ID */
                providerId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Provider disconnected */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    completeAgentAuthProviderLogin: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Auth provider ID */
                providerId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CompleteAgentAuthProviderLoginRequest"];
            };
        };
        responses: {
            /** @description Login completed */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["CompleteAgentAuthProviderLoginResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteAgentModel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Model ID */
                modelId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Model deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Model not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateAgentModel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Model ID */
                modelId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateModelConfigRequest"];
            };
        };
        responses: {
            /** @description Model updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ModelConfigResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Model not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    setDefaultAgentModel: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["SetDefaultModelRequest"];
            };
        };
        responses: {
            /** @description Default model set */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SetDefaultModelResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Model not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAgentMemory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Agent memory overview */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentMemoryResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateAgentMemory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateAgentMemoryRequest"];
            };
        };
        responses: {
            /** @description Memory updated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteAgentMemory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Memory cleared successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAgentDAGMemory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Name of the DAG */
                dagName: components["schemas"]["DAGName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG memory content */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentDAGMemoryResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateAgentDAGMemory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Name of the DAG */
                dagName: components["schemas"]["DAGName"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateAgentMemoryRequest"];
            };
        };
        responses: {
            /** @description DAG memory updated successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteAgentDAGMemory: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Name of the DAG */
                dagName: components["schemas"]["DAGName"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description DAG memory cleared successfully */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listModelPresets: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of model presets */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListModelPresetsResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listAgentTools: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of tools */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListAgentToolsResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listAgentSouls: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description page number of items to fetch (default is 1) */
                page?: components["parameters"]["Page"];
                /** @description number of items per page (default is 30, max is 100) */
                perPage?: components["parameters"]["PerPage"];
                /** @description Search query (matches name, description) */
                q?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of souls */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListSoulsResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createAgentSoul: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateSoulRequest"];
            };
        };
        responses: {
            /** @description Soul created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SoulResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Soul already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAgentSoul: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The soul ID */
                soulId: components["parameters"]["SoulId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Soul details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SoulResponse"];
                };
            };
            /** @description Invalid soul ID */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Soul not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteAgentSoul: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The soul ID */
                soulId: components["parameters"]["SoulId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Soul deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Invalid soul ID */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Soul not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateAgentSoul: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The soul ID */
                soulId: components["parameters"]["SoulId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateSoulRequest"];
            };
        };
        responses: {
            /** @description Soul updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SoulResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Requires admin role */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Soul not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listAgentSessions: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Pagination mode. Use `cursor` for the agent session sidebar infinite-loading flow; omit or use `offset` for compatibility pagination. */
                paginationMode?: components["parameters"]["AgentSessionPaginationMode"];
                /** @description Opaque cursor for loading the next page of older agent sessions */
                cursor?: components["parameters"]["AgentSessionCursor"];
                /** @description page number of items to fetch (default is 1) */
                page?: components["parameters"]["Page"];
                /** @description number of items per page (default is 30, max is 100) */
                perPage?: components["parameters"]["PerPage"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Paginated list of sessions */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["ListAgentSessionsResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createAgentSession: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AgentChatRequest"];
            };
        };
        responses: {
            /** @description Session created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["CreateAgentSessionResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Agent not configured */
            503: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getAgentSession: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Unique identifier of the agent session */
                sessionId: components["parameters"]["AgentSessionId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Session details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentSessionDetailResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Session not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    chatAgentSession: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Unique identifier of the agent session */
                sessionId: components["parameters"]["AgentSessionId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AgentChatRequest"];
            };
        };
        responses: {
            /** @description Message accepted */
            202: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentStatusResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Session not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Agent not configured */
            503: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    cancelAgentSession: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Unique identifier of the agent session */
                sessionId: components["parameters"]["AgentSessionId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Session cancelled */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentStatusResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Session not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    respondAgentSession: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description Unique identifier of the agent session */
                sessionId: components["parameters"]["AgentSessionId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["AgentUserPromptResponse"];
            };
        };
        responses: {
            /** @description Response accepted */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["AgentStatusResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Session not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Prompt expired or already answered */
            410: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    activateLicense: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description License key (e.g. DAGU-XXXX-XXXX-XXXX-XXXX) */
                    key: string;
                };
            };
        };
        responses: {
            /** @description Activation successful */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        plan?: string;
                        features?: string[];
                        expiry?: string;
                    };
                };
            };
            /** @description Invalid key or activation failed */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Insufficient permissions */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deactivateLicense: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description License deactivated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        message?: string;
                    };
                };
            };
            /** @description No active license or license configured via env var */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Insufficient permissions */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listDocs: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description page number of items to fetch (default is 1) */
                page?: components["parameters"]["Page"];
                /** @description number of items per page (default is 30, max is 100) */
                perPage?: components["parameters"]["PerPage"];
                /** @description If true, returns flat list instead of tree */
                flat?: boolean;
                /** @description Field to sort by:
                 *     - `name`: Alphabetically by display name (case-insensitive)
                 *     - `type`: By node type (dirs vs files), then alphabetically within each group
                 *     - `mtime`: By last modification time
                 *      */
                sort?: PathsDocsGetParametersQuerySort;
                /** @description Sort order. For type: asc=folders first. For mtime: desc=newest first. */
                order?: PathsDocsGetParametersQueryOrder;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of documents */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DocListResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createDoc: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateDocRequest"];
            };
        };
        responses: {
            /** @description Document created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        message?: string;
                    };
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Document already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    searchDocs: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Search query */
                q: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Search results */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DocSearchResponse"];
                };
            };
            /** @description Missing query parameter */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getDoc: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Document path (may include slashes for nested docs) */
                path: components["schemas"]["DocPath"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Document details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DocResponse"];
                };
            };
            /** @description Document not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteDoc: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Document path (may include slashes for nested docs) */
                path: components["schemas"]["DocPath"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Document deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Document not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateDoc: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Document path (may include slashes for nested docs) */
                path: components["schemas"]["DocPath"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateDocRequest"];
            };
        };
        responses: {
            /** @description Document updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        message?: string;
                    };
                };
            };
            /** @description Document not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    renameDoc: {
        parameters: {
            query: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
                /** @description Current document or directory path (may include slashes for nested docs) */
                path: components["schemas"]["DocPath"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RenameDocRequest"];
            };
        };
        responses: {
            /** @description Document or directory renamed */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        message?: string;
                    };
                };
            };
            /** @description Document or directory not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Target path already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteDocBatch: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Workspace selector. For list and search APIs, use all, default, or a workspace name. Omitted means all. For document target APIs, use default or a workspace name; omitted means default. */
                workspace?: components["parameters"]["Workspace"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["DocDeleteBatchRequest"];
            };
        };
        responses: {
            /** @description Batch delete completed (may include partial failures) */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["DocDeleteBatchResponse"];
                };
            };
            /** @description Unexpected error */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listRemoteNodes: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of remote nodes */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["RemoteNodeListResponse"];
                };
            };
            /** @description Forbidden */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createRemoteNode: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateRemoteNodeRequest"];
            };
        };
        responses: {
            /** @description Remote node created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["RemoteNodeResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Name already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getRemoteNode: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The unique identifier of the remote node */
                remoteNodeId: components["parameters"]["RemoteNodeId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Remote node details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["RemoteNodeResponse"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteRemoteNode: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The unique identifier of the remote node */
                remoteNodeId: components["parameters"]["RemoteNodeId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Remote node deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Cannot delete config-sourced node */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateRemoteNode: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The unique identifier of the remote node */
                remoteNodeId: components["parameters"]["RemoteNodeId"];
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateRemoteNodeRequest"];
            };
        };
        responses: {
            /** @description Remote node updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["RemoteNodeResponse"];
                };
            };
            /** @description Cannot modify config-sourced node */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Name already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    testRemoteNodeConnection: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                /** @description The unique identifier of the remote node */
                remoteNodeId: components["parameters"]["RemoteNodeId"];
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Connection test result */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["TestRemoteNodeConnectionResponse"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listSecrets: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
                /** @description Single secret scope. Use global for workspace-less secrets or a workspace name. Omit for global. all and default are not supported for secrets. */
                workspace?: string;
                limit?: number;
                offset?: number;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of secrets */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SecretListResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createSecret: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateSecretRequest"];
            };
        };
        responses: {
            /** @description Secret created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SecretResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Secret already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getSecret: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                secretId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Secret metadata */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SecretResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteSecret: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                secretId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Secret deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateSecret: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                secretId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateSecretRequest"];
            };
        };
        responses: {
            /** @description Secret updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SecretResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    writeSecretVersion: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                secretId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["WriteSecretVersionRequest"];
            };
        };
        responses: {
            /** @description Secret value written */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SecretResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    disableSecret: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                secretId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Secret disabled */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SecretResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    enableSecret: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                secretId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Secret enabled */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["SecretResponse"];
                };
            };
            /** @description Not authenticated */
            401: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not authorized */
            403: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    listWorkspaces: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description List of workspaces */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WorkspaceListResponse"];
                };
            };
            /** @description Generic error response */
            default: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    createWorkspace: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["CreateWorkspaceRequest"];
            };
        };
        responses: {
            /** @description Workspace created */
            201: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WorkspaceResponse"];
                };
            };
            /** @description Invalid request */
            400: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Name already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    getWorkspace: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Workspace details */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WorkspaceResponse"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    deleteWorkspace: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            /** @description Workspace deleted */
            204: {
                headers: {
                    [name: string]: unknown;
                };
                content?: never;
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
    updateWorkspace: {
        parameters: {
            query?: {
                /** @description name of the remote node */
                remoteNode?: components["parameters"]["RemoteNode"];
            };
            header?: never;
            path: {
                workspaceId: string;
            };
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["UpdateWorkspaceRequest"];
            };
        };
        responses: {
            /** @description Workspace updated */
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["WorkspaceResponse"];
                };
            };
            /** @description Not found */
            404: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
            /** @description Name already exists */
            409: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": components["schemas"]["Error"];
                };
            };
        };
    };
}
export enum PathsDagsGetParametersQuerySort {
    name = "name",
    nextRun = "nextRun"
}
export enum PathsDagsGetParametersQueryOrder {
    asc = "asc",
    desc = "desc"
}
export enum PathsDocsGetParametersQuerySort {
    name = "name",
    type = "type",
    mtime = "mtime"
}
export enum PathsDocsGetParametersQueryOrder {
    asc = "asc",
    desc = "desc"
}
export enum ChatMessageRole {
    system = "system",
    user = "user",
    assistant = "assistant",
    tool = "tool"
}
export enum ErrorCode {
    forbidden = "forbidden",
    bad_request = "bad_request",
    not_found = "not_found",
    internal_error = "internal_error",
    unauthorized = "unauthorized",
    bad_gateway = "bad_gateway",
    remote_node_error = "remote_node_error",
    max_run_reached = "max_run_reached",
    not_running = "not_running",
    already_exists = "already_exists",
    auth_unauthorized = "auth.unauthorized",
    auth_token_invalid = "auth.token_invalid",
    auth_forbidden = "auth.forbidden",
    timeout = "timeout"
}
export enum WebhookAuthMode {
    token_only = "token_only",
    token_and_hmac = "token_and_hmac",
    hmac_only = "hmac_only"
}
export enum WebhookHMACEnforcementMode {
    strict = "strict",
    observe = "observe"
}
export enum WebhookHMACConfigureRequestAuthMode {
    token_and_hmac = "token_and_hmac",
    hmac_only = "hmac_only"
}
export enum NotificationProviderType {
    email = "email",
    webhook = "webhook",
    slack = "slack",
    telegram = "telegram"
}
export enum NotificationEventType {
    dag_run_waiting = "dag.run.waiting",
    dag_run_succeeded = "dag.run.succeeded",
    dag_run_failed = "dag.run.failed",
    dag_run_aborted = "dag.run.aborted",
    dag_run_rejected = "dag.run.rejected"
}
export enum NotificationRouteScope {
    global = "global",
    workspace = "workspace"
}
export enum IncidentProviderType {
    pagerduty = "pagerduty",
    solarwinds_incident_response = "solarwinds_incident_response"
}
export enum IncidentSeverity {
    critical = "critical",
    error = "error",
    warning = "warning",
    info = "info"
}
export enum IncidentPolicyScope {
    global = "global",
    workspace = "workspace",
    dag = "dag"
}
export enum IncidentPagerDutyProviderInputEnvelopeType {
    pagerduty = "pagerduty"
}
export enum IncidentSolarWindsProviderInputEnvelopeType {
    solarwinds_incident_response = "solarwinds_incident_response"
}
export enum Stream {
    stdout = "stdout",
    stderr = "stderr"
}
export enum HealthResponseStatus {
    healthy = "healthy",
    unhealthy = "unhealthy"
}
export enum ScheduleKind {
    cron = "cron",
    at = "at"
}
export enum Status {
    NotStarted = 0,
    Running = 1,
    Failed = 2,
    Aborted = 3,
    Success = 4,
    Queued = 5,
    PartialSuccess = 6,
    Waiting = 7,
    Rejected = 8
}
export enum StatusLabel {
    not_started = "not_started",
    running = "running",
    failed = "failed",
    aborted = "aborted",
    succeeded = "succeeded",
    queued = "queued",
    partially_succeeded = "partially_succeeded",
    waiting = "waiting",
    rejected = "rejected"
}
export enum TriggerType {
    unknown = "unknown",
    scheduler = "scheduler",
    manual = "manual",
    webhook = "webhook",
    subdag = "subdag",
    retry = "retry",
    catchup = "catchup"
}
export enum NodeStatus {
    NotStarted = 0,
    Running = 1,
    Failed = 2,
    Aborted = 3,
    Success = 4,
    Skipped = 5,
    PartialSuccess = 6,
    Waiting = 7,
    Rejected = 8,
    Retrying = 9
}
export enum NodeStatusLabel {
    not_started = "not_started",
    running = "running",
    failed = "failed",
    aborted = "aborted",
    succeeded = "succeeded",
    skipped = "skipped",
    partially_succeeded = "partially_succeeded",
    waiting = "waiting",
    rejected = "rejected",
    retrying = "retrying"
}
export enum SchedulerInstanceStatus {
    active = "active",
    inactive = "inactive",
    unknown = "unknown"
}
export enum CoordinatorInstanceStatus {
    active = "active",
    inactive = "inactive",
    unknown = "unknown"
}
export enum TunnelStatusResponseProvider {
    tailscale = "tailscale"
}
export enum TunnelStatusResponseStatus {
    disabled = "disabled",
    connecting = "connecting",
    connected = "connected",
    reconnecting = "reconnecting",
    error = "error"
}
export enum WorkerHealthStatus {
    healthy = "healthy",
    warning = "warning",
    unhealthy = "unhealthy"
}
export enum ParamDefType {
    string = "string",
    integer = "integer",
    number = "number",
    boolean = "boolean"
}
export enum ArtifactNodeType {
    directory = "directory",
    file = "file"
}
export enum ArtifactPreviewKind {
    markdown = "markdown",
    text = "text",
    image = "image",
    binary = "binary"
}
export enum RepeatMode {
    While = "while",
    Until = "until"
}
export enum QueueType {
    global = "global",
    dag_based = "dag-based"
}
export enum UserRole {
    admin = "admin",
    manager = "manager",
    developer = "developer",
    operator = "operator",
    viewer = "viewer"
}
export enum UserAuthProvider {
    builtin = "builtin",
    oidc = "oidc"
}
export enum SyncStatus {
    synced = "synced",
    modified = "modified",
    untracked = "untracked",
    conflict = "conflict",
    missing = "missing"
}
export enum SyncSummary {
    synced = "synced",
    pending = "pending",
    conflict = "conflict",
    missing = "missing",
    error = "error"
}
export enum SyncItemKind {
    dag = "dag",
    config = "config",
    memory = "memory",
    skill = "skill",
    soul = "soul",
    doc = "doc"
}
export enum SyncAuthConfigType {
    token = "token",
    ssh = "ssh"
}
export enum AgentBashPolicyDefaultBehavior {
    allow = "allow",
    deny = "deny"
}
export enum AgentBashPolicyDenyBehavior {
    ask_user = "ask_user",
    block = "block"
}
export enum AgentBashRuleAction {
    allow = "allow",
    deny = "deny"
}
export enum AgentWebToolsBackend {
    tavily = "tavily",
    firecrawl = "firecrawl"
}
export enum AgentTavilyWebToolsConfigSearchDepth {
    basic = "basic",
    advanced = "advanced",
    fast = "fast",
    ultra_fast = "ultra-fast"
}
export enum ModelConfigResponseProvider {
    anthropic = "anthropic",
    openai = "openai",
    openai_codex = "openai-codex",
    gemini = "gemini",
    openrouter = "openrouter",
    local = "local",
    zai = "zai",
    opencode = "opencode"
}
export enum ModelConfigResponseThinkingEffort {
    low = "low",
    medium = "medium",
    high = "high",
    xhigh = "xhigh"
}
export enum CreateModelConfigRequestProvider {
    anthropic = "anthropic",
    openai = "openai",
    openai_codex = "openai-codex",
    gemini = "gemini",
    openrouter = "openrouter",
    local = "local",
    zai = "zai",
    opencode = "opencode"
}
export enum CreateModelConfigRequestThinkingEffort {
    low = "low",
    medium = "medium",
    high = "high",
    xhigh = "xhigh"
}
export enum UpdateModelConfigRequestProvider {
    anthropic = "anthropic",
    openai = "openai",
    openai_codex = "openai-codex",
    gemini = "gemini",
    openrouter = "openrouter",
    local = "local",
    zai = "zai",
    opencode = "opencode"
}
export enum UpdateModelConfigRequestThinkingEffort {
    low = "low",
    medium = "medium",
    high = "high",
    xhigh = "xhigh"
}
export enum DocTreeNodeResponseType {
    file = "file",
    directory = "directory"
}
export enum ModelPresetProvider {
    anthropic = "anthropic",
    openai = "openai",
    openai_codex = "openai-codex",
    gemini = "gemini",
    openrouter = "openrouter",
    local = "local",
    zai = "zai",
    opencode = "opencode"
}
export enum ModelPresetThinkingEffort {
    low = "low",
    medium = "medium",
    high = "high",
    xhigh = "xhigh"
}
export enum AgentUserPromptPromptType {
    general = "general",
    command_approval = "command_approval"
}
export enum AgentMessageType {
    user = "user",
    assistant = "assistant",
    error = "error",
    ui_action = "ui_action",
    user_prompt = "user_prompt"
}
export enum AgentDelegateSnapshotStatus {
    running = "running",
    completed = "completed"
}
export enum CreateRemoteNodeRequestAuthType {
    none = "none",
    basic = "basic",
    token = "token"
}
export enum UpdateRemoteNodeRequestAuthType {
    none = "none",
    basic = "basic",
    token = "token"
}
export enum RemoteNodeResponseAuthType {
    none = "none",
    basic = "basic",
    token = "token"
}
export enum RemoteNodeResponseSource {
    config = "config",
    store = "store"
}
export enum SecretProviderType {
    dagu_managed = "dagu-managed",
    vault = "vault",
    kubernetes = "kubernetes",
    gcp_secret_manager = "gcp-secret-manager",
    aws_secrets_manager = "aws-secrets-manager",
    azure_key_vault = "azure-key-vault"
}
export enum SecretStatus {
    active = "active",
    disabled = "disabled"
}
export enum CreateSecretRequestProviderType {
    dagu_managed = "dagu-managed"
}
export enum ComponentsParametersAgentSessionPaginationMode {
    offset = "offset",
    cursor = "cursor"
}
export enum ComponentsParametersEventLogPaginationMode {
    offset = "offset",
    cursor = "cursor"
}
