import { APIResource } from "../core/resource.js";
import * as ToolsAPI from "./tools/tools.js";
import { ToolDefinitionsOffsetPage } from "./tools/tools.js";
import { APIPromise } from "../core/api-promise.js";
import { OffsetPage, type OffsetPageParams, PagePromise } from "../core/pagination.js";
import { RequestOptions } from "../internal/request-options.js";
export declare class Workers extends APIResource {
    /**
     * Create a worker
     */
    create(body: WorkerCreateParams, options?: RequestOptions): APIPromise<WorkerResponse>;
    /**
     * Update a worker
     */
    update(id: string, body: WorkerUpdateParams, options?: RequestOptions): APIPromise<WorkerResponse>;
    /**
     * List all workers with their definitions
     */
    list(query?: WorkerListParams | null | undefined, options?: RequestOptions): PagePromise<WorkerResponsesOffsetPage, WorkerResponse>;
    /**
     * Delete a worker
     */
    delete(id: string, options?: RequestOptions): APIPromise<void>;
    /**
     * Get a worker by ID
     */
    get(id: string, options?: RequestOptions): APIPromise<WorkerResponse>;
    /**
     * Get the health of a worker
     */
    health(id: string, options?: RequestOptions): APIPromise<WorkerHealthResponse>;
    /**
     * Returns a page of tools
     */
    tools(id: string, query?: WorkerToolsParams | null | undefined, options?: RequestOptions): PagePromise<ToolDefinitionsOffsetPage, ToolsAPI.ToolDefinition>;
}
export type WorkerResponsesOffsetPage = OffsetPage<WorkerResponse>;
export interface CreateWorkerRequest {
    id: string;
    enabled?: boolean;
    http?: CreateWorkerRequest.HTTP;
    mcp?: CreateWorkerRequest.Mcp;
    type?: string;
}
export declare namespace CreateWorkerRequest {
    interface HTTP {
        retry: number;
        secret: string;
        timeout: number;
        uri: string;
    }
    interface Mcp {
        retry: number;
        timeout: number;
        uri: string;
        headers?: {
            [key: string]: string;
        };
        oauth2?: Mcp.Oauth2;
        secrets?: {
            [key: string]: string;
        };
    }
    namespace Mcp {
        interface Oauth2 {
            authorization_url?: string;
            client_id?: string;
            client_secret?: string;
            external_id?: string;
        }
    }
}
export interface UpdateWorkerRequest {
    enabled?: boolean;
    http?: UpdateWorkerRequest.HTTP;
    mcp?: UpdateWorkerRequest.Mcp;
}
export declare namespace UpdateWorkerRequest {
    interface HTTP {
        retry?: number;
        secret?: string;
        timeout?: number;
        uri?: string;
    }
    interface Mcp {
        headers?: {
            [key: string]: string;
        };
        oauth2?: Mcp.Oauth2;
        retry?: number;
        secrets?: {
            [key: string]: string;
        };
        timeout?: number;
        uri?: string;
    }
    namespace Mcp {
        interface Oauth2 {
            authorization_url?: string;
            client_id?: string;
            client_secret?: string;
        }
    }
}
export interface WorkerHealthResponse {
    id?: string;
    enabled?: boolean;
    healthy?: boolean;
    message?: string;
}
export interface WorkerResponse {
    id?: string;
    binding?: WorkerResponse.Binding;
    enabled?: boolean;
    http?: WorkerResponse.HTTP;
    managed?: boolean;
    mcp?: WorkerResponse.Mcp;
    requirements?: WorkerResponse.Requirements;
    type?: 'http' | 'mcp' | 'unknown';
}
export declare namespace WorkerResponse {
    interface Binding {
        id?: string;
        type?: 'static' | 'tenant' | 'project' | 'account';
    }
    interface HTTP {
        retry?: number;
        secret?: HTTP.Secret;
        timeout?: number;
        uri?: string;
    }
    namespace HTTP {
        interface Secret {
            binding?: 'static' | 'tenant' | 'project' | 'account';
            editable?: boolean;
            exists?: boolean;
            value?: string;
        }
    }
    interface Mcp {
        headers?: {
            [key: string]: string;
        };
        oauth2?: Mcp.Oauth2;
        retry?: number;
        secrets?: {
            [key: string]: Mcp.Secrets;
        };
        timeout?: number;
        uri?: string;
    }
    namespace Mcp {
        interface Oauth2 {
            authorization_url?: string;
            client_id?: string;
            client_secret?: Oauth2.ClientSecret;
            external_id?: string;
            redirect_uri?: string;
            supported_scopes?: Array<string>;
        }
        namespace Oauth2 {
            interface ClientSecret {
                binding?: 'static' | 'tenant' | 'project' | 'account';
                editable?: boolean;
                exists?: boolean;
                value?: string;
            }
        }
        interface Secrets {
            binding?: 'static' | 'tenant' | 'project' | 'account';
            editable?: boolean;
            exists?: boolean;
            value?: string;
        }
    }
    interface Requirements {
        authorization?: Requirements.Authorization;
        met?: boolean;
    }
    namespace Requirements {
        interface Authorization {
            met?: boolean;
            oauth2?: Authorization.Oauth2;
        }
        namespace Authorization {
            interface Oauth2 {
                met?: boolean;
            }
        }
    }
}
export interface WorkerCreateParams {
    id: string;
    enabled?: boolean;
    http?: WorkerCreateParams.HTTP;
    mcp?: WorkerCreateParams.Mcp;
    type?: string;
}
export declare namespace WorkerCreateParams {
    interface HTTP {
        retry: number;
        secret: string;
        timeout: number;
        uri: string;
    }
    interface Mcp {
        retry: number;
        timeout: number;
        uri: string;
        headers?: {
            [key: string]: string;
        };
        oauth2?: Mcp.Oauth2;
        secrets?: {
            [key: string]: string;
        };
    }
    namespace Mcp {
        interface Oauth2 {
            authorization_url?: string;
            client_id?: string;
            client_secret?: string;
            external_id?: string;
        }
    }
}
export interface WorkerUpdateParams {
    enabled?: boolean;
    http?: WorkerUpdateParams.HTTP;
    mcp?: WorkerUpdateParams.Mcp;
}
export declare namespace WorkerUpdateParams {
    interface HTTP {
        retry?: number;
        secret?: string;
        timeout?: number;
        uri?: string;
    }
    interface Mcp {
        headers?: {
            [key: string]: string;
        };
        oauth2?: Mcp.Oauth2;
        retry?: number;
        secrets?: {
            [key: string]: string;
        };
        timeout?: number;
        uri?: string;
    }
    namespace Mcp {
        interface Oauth2 {
            authorization_url?: string;
            client_id?: string;
            client_secret?: string;
        }
    }
}
export interface WorkerListParams extends OffsetPageParams {
}
export interface WorkerToolsParams extends OffsetPageParams {
}
export declare namespace Workers {
    export { type CreateWorkerRequest as CreateWorkerRequest, type UpdateWorkerRequest as UpdateWorkerRequest, type WorkerHealthResponse as WorkerHealthResponse, type WorkerResponse as WorkerResponse, type WorkerResponsesOffsetPage as WorkerResponsesOffsetPage, type WorkerCreateParams as WorkerCreateParams, type WorkerUpdateParams as WorkerUpdateParams, type WorkerListParams as WorkerListParams, type WorkerToolsParams as WorkerToolsParams, };
}
export { type ToolDefinitionsOffsetPage };
//# sourceMappingURL=workers.d.ts.map