// This file is auto-generated by @hey-api/openapi-ts

export type ClientOptions = {
    baseUrl: string;
};

export type AccountsAccount = {
    avatar_url?: string;
    created_at?: string;
    display_name?: string;
    email?: string;
    id?: string;
    is_active?: boolean;
    last_login_at?: string;
    role?: string;
    updated_at?: string;
    username?: string;
};

export type AccountsCreateAccountRequest = {
    avatar_url?: string;
    display_name?: string;
    email?: string;
    is_active?: boolean;
    password?: string;
    role?: string;
    username?: string;
};

export type AccountsListAccountsResponse = {
    items?: Array<AccountsAccount>;
};

export type AccountsResetPasswordRequest = {
    new_password?: string;
};

export type AccountsUpdateAccountRequest = {
    avatar_url?: string;
    display_name?: string;
    is_active?: boolean;
    role?: string;
};

export type AccountsUpdatePasswordRequest = {
    current_password?: string;
    new_password?: string;
};

export type AccountsUpdateProfileRequest = {
    avatar_url?: string;
    display_name?: string;
};

export type AclChannelIdentityCandidate = {
    avatar_url?: string;
    channel?: string;
    channel_subject_id?: string;
    display_name?: string;
    id?: string;
    linked_avatar_url?: string;
    linked_display_name?: string;
    linked_username?: string;
    user_id?: string;
};

export type AclChannelIdentityCandidateListResponse = {
    items?: Array<AclChannelIdentityCandidate>;
};

export type AclListRulesResponse = {
    items?: Array<AclRule>;
};

export type AclObservedConversationCandidate = {
    channel?: string;
    conversation_id?: string;
    conversation_name?: string;
    conversation_type?: string;
    last_observed_at?: string;
    route_id?: string;
    thread_id?: string;
};

export type AclObservedConversationCandidateListResponse = {
    items?: Array<AclObservedConversationCandidate>;
};

export type AclRule = {
    action?: string;
    bot_id?: string;
    channel_identity_avatar_url?: string;
    channel_identity_display_name?: string;
    channel_identity_id?: string;
    channel_subject_id?: string;
    channel_type?: string;
    created_at?: string;
    effect?: string;
    id?: string;
    linked_user_avatar_url?: string;
    linked_user_display_name?: string;
    linked_user_id?: string;
    linked_user_username?: string;
    source_scope?: AclSourceScope;
    subject_kind?: string;
    updated_at?: string;
    user_avatar_url?: string;
    user_display_name?: string;
    user_id?: string;
    user_username?: string;
};

export type AclSourceScope = {
    channel?: string;
    conversation_id?: string;
    conversation_type?: string;
    thread_id?: string;
};

export type AclUpsertRuleRequest = {
    channel_identity_id?: string;
    source_scope?: AclSourceScope;
    user_id?: string;
};

export type AclUserCandidate = {
    avatar_url?: string;
    display_name?: string;
    email?: string;
    id?: string;
    username?: string;
};

export type AclUserCandidateListResponse = {
    items?: Array<AclUserCandidate>;
};

export type AdaptersCdfPoint = {
    /**
     * cumulative weight fraction [0.0, 1.0]
     */
    cumulative?: number;
    /**
     * rank position (1-based, sorted by value desc)
     */
    k?: number;
};

export type AdaptersCompactResult = {
    after_count?: number;
    before_count?: number;
    ratio?: number;
    results?: Array<AdaptersMemoryItem>;
};

export type AdaptersDeleteResponse = {
    message?: string;
};

export type AdaptersHealthStatus = {
    error?: string;
    ok?: boolean;
};

export type AdaptersMemoryItem = {
    agent_id?: string;
    bot_id?: string;
    cdf_curve?: Array<AdaptersCdfPoint>;
    created_at?: string;
    hash?: string;
    id?: string;
    memory?: string;
    metadata?: {
        [key: string]: unknown;
    };
    run_id?: string;
    score?: number;
    top_k_buckets?: Array<AdaptersTopKBucket>;
    updated_at?: string;
};

export type AdaptersMemoryStatusResponse = {
    can_manual_sync?: boolean;
    encoder?: AdaptersHealthStatus;
    indexed_count?: number;
    markdown_file_count?: number;
    memory_mode?: string;
    overview_path?: string;
    provider_type?: string;
    qdrant?: AdaptersHealthStatus;
    qdrant_collection?: string;
    source_count?: number;
    source_dir?: string;
};

export type AdaptersMessage = {
    content?: string;
    role?: string;
};

export type AdaptersProviderCollectionStatus = {
    exists?: boolean;
    name?: string;
    points?: number;
    qdrant?: AdaptersHealthStatus;
};

export type AdaptersProviderConfigSchema = {
    fields?: {
        [key: string]: AdaptersProviderFieldSchema;
    };
};

export type AdaptersProviderCreateRequest = {
    config?: {
        [key: string]: unknown;
    };
    name?: string;
    provider?: AdaptersProviderType;
};

export type AdaptersProviderFieldSchema = {
    description?: string;
    example?: unknown;
    required?: boolean;
    secret?: boolean;
    title?: string;
    type?: string;
};

export type AdaptersProviderGetResponse = {
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    is_default?: boolean;
    name?: string;
    provider?: string;
    updated_at?: string;
};

export type AdaptersProviderMeta = {
    config_schema?: AdaptersProviderConfigSchema;
    display_name?: string;
    provider?: string;
};

export type AdaptersProviderStatusResponse = {
    collections?: Array<AdaptersProviderCollectionStatus>;
    embedding_model_id?: string;
    memory_mode?: string;
    provider_type?: string;
};

export type AdaptersProviderType = 'builtin' | 'mem0' | 'openviking';

export type AdaptersProviderUpdateRequest = {
    config?: {
        [key: string]: unknown;
    };
    name?: string;
};

export type AdaptersRebuildResult = {
    fs_count?: number;
    missing_count?: number;
    restored_count?: number;
    storage_count?: number;
};

export type AdaptersSearchResponse = {
    relations?: Array<unknown>;
    results?: Array<AdaptersMemoryItem>;
};

export type AdaptersTopKBucket = {
    /**
     * sparse dimension index (term hash)
     */
    index?: number;
    /**
     * weight (term frequency)
     */
    value?: number;
};

export type AdaptersUsageResponse = {
    avg_text_bytes?: number;
    count?: number;
    estimated_storage_bytes?: number;
    total_text_bytes?: number;
};

export type BotsBot = {
    avatar_url?: string;
    check_issue_count?: number;
    check_state?: string;
    created_at?: string;
    display_name?: string;
    id?: string;
    is_active?: boolean;
    metadata?: {
        [key: string]: unknown;
    };
    owner_user_id?: string;
    status?: string;
    updated_at?: string;
};

export type BotsBotCheck = {
    detail?: string;
    id?: string;
    metadata?: {
        [key: string]: unknown;
    };
    status?: string;
    subtitle?: string;
    summary?: string;
    title_key?: string;
    type?: string;
};

export type BotsCreateBotRequest = {
    avatar_url?: string;
    display_name?: string;
    is_active?: boolean;
    metadata?: {
        [key: string]: unknown;
    };
};

export type BotsListBotsResponse = {
    items?: Array<BotsBot>;
};

export type BotsListChecksResponse = {
    items?: Array<BotsBotCheck>;
};

export type BotsTransferBotRequest = {
    owner_user_id?: string;
};

export type BotsUpdateBotRequest = {
    avatar_url?: string;
    display_name?: string;
    is_active?: boolean;
    metadata?: {
        [key: string]: unknown;
    };
};

export type BrowsercontextsBrowserContext = {
    config?: Array<number>;
    created_at?: string;
    id?: string;
    name?: string;
    updated_at?: string;
};

export type BrowsercontextsCreateRequest = {
    config?: Array<number>;
    name?: string;
};

export type BrowsercontextsUpdateRequest = {
    config?: Array<number>;
    name?: string;
};

export type ChannelAction = {
    label?: string;
    type?: string;
    url?: string;
    value?: string;
};

export type ChannelAttachment = {
    /**
     * data URL for agent delivery
     */
    base64?: string;
    caption?: string;
    content_hash?: string;
    duration_ms?: number;
    height?: number;
    metadata?: {
        [key: string]: unknown;
    };
    mime?: string;
    name?: string;
    platform_key?: string;
    size?: number;
    source_platform?: string;
    thumbnail_url?: string;
    type?: ChannelAttachmentType;
    url?: string;
    width?: number;
};

export type ChannelAttachmentType = 'image' | 'audio' | 'video' | 'voice' | 'file' | 'gif';

export type ChannelChannelCapabilities = {
    attachments?: boolean;
    block_streaming?: boolean;
    buttons?: boolean;
    chat_types?: Array<string>;
    edit?: boolean;
    markdown?: boolean;
    media?: boolean;
    native_commands?: boolean;
    polls?: boolean;
    reactions?: boolean;
    reply?: boolean;
    rich_text?: boolean;
    streaming?: boolean;
    text?: boolean;
    threads?: boolean;
    unsend?: boolean;
};

export type ChannelChannelConfig = {
    bot_id?: string;
    channel_type?: string;
    created_at?: string;
    credentials?: {
        [key: string]: unknown;
    };
    disabled?: boolean;
    external_identity?: string;
    id?: string;
    routing?: {
        [key: string]: unknown;
    };
    self_identity?: {
        [key: string]: unknown;
    };
    updated_at?: string;
    verified_at?: string;
};

export type ChannelChannelIdentityBinding = {
    channel_identity_id?: string;
    channel_type?: string;
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    updated_at?: string;
};

export type ChannelConfigSchema = {
    fields?: {
        [key: string]: ChannelFieldSchema;
    };
    version?: number;
};

export type ChannelFieldSchema = {
    description?: string;
    enum?: Array<string>;
    example?: unknown;
    required?: boolean;
    title?: string;
    type?: ChannelFieldType;
};

export type ChannelFieldType = 'string' | 'secret' | 'bool' | 'number' | 'enum';

export type ChannelMessage = {
    actions?: Array<ChannelAction>;
    attachments?: Array<ChannelAttachment>;
    format?: ChannelMessageFormat;
    id?: string;
    metadata?: {
        [key: string]: unknown;
    };
    parts?: Array<ChannelMessagePart>;
    reply?: ChannelReplyRef;
    text?: string;
    thread?: ChannelThreadRef;
};

export type ChannelMessageFormat = 'plain' | 'markdown' | 'rich';

export type ChannelMessagePart = {
    channel_identity_id?: string;
    emoji?: string;
    language?: string;
    metadata?: {
        [key: string]: unknown;
    };
    styles?: Array<ChannelMessageTextStyle>;
    text?: string;
    type?: ChannelMessagePartType;
    url?: string;
};

export type ChannelMessagePartType = 'text' | 'link' | 'code_block' | 'mention' | 'emoji';

export type ChannelMessageTextStyle = 'bold' | 'italic' | 'strikethrough' | 'code';

export type ChannelReplyRef = {
    message_id?: string;
    target?: string;
};

export type ChannelSendRequest = {
    channel_identity_id?: string;
    message?: ChannelMessage;
    target?: string;
};

export type ChannelTargetHint = {
    example?: string;
    label?: string;
};

export type ChannelTargetSpec = {
    format?: string;
    hints?: Array<ChannelTargetHint>;
};

export type ChannelThreadRef = {
    id?: string;
};

export type ChannelUpdateChannelStatusRequest = {
    disabled?: boolean;
};

export type ChannelUpsertChannelIdentityConfigRequest = {
    config?: {
        [key: string]: unknown;
    };
};

export type ChannelUpsertConfigRequest = {
    credentials?: {
        [key: string]: unknown;
    };
    disabled?: boolean;
    external_identity?: string;
    routing?: {
        [key: string]: unknown;
    };
    self_identity?: {
        [key: string]: unknown;
    };
    verified_at?: string;
};

export type CompactionListLogsResponse = {
    items?: Array<CompactionLog>;
};

export type CompactionLog = {
    bot_id?: string;
    completed_at?: string;
    error_message?: string;
    id?: string;
    message_count?: number;
    model_id?: string;
    session_id?: string;
    started_at?: string;
    status?: string;
    summary?: string;
    usage?: unknown;
};

export type EmailBindingResponse = {
    bot_id?: string;
    can_delete?: boolean;
    can_read?: boolean;
    can_write?: boolean;
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    email_address?: string;
    email_provider_id?: string;
    id?: string;
    updated_at?: string;
};

export type EmailConfigSchema = {
    fields?: Array<EmailFieldSchema>;
};

export type EmailCreateBindingRequest = {
    can_delete?: boolean;
    can_read?: boolean;
    can_write?: boolean;
    config?: {
        [key: string]: unknown;
    };
    email_address?: string;
    email_provider_id?: string;
};

export type EmailCreateProviderRequest = {
    config?: {
        [key: string]: unknown;
    };
    name?: string;
    provider?: string;
};

export type EmailFieldSchema = {
    description?: string;
    enum?: Array<string>;
    example?: unknown;
    key?: string;
    order?: number;
    required?: boolean;
    title?: string;
    type?: string;
};

export type EmailOutboxItemResponse = {
    attachments?: Array<unknown>;
    body_html?: string;
    body_text?: string;
    bot_id?: string;
    created_at?: string;
    error?: string;
    from?: string;
    id?: string;
    message_id?: string;
    provider_id?: string;
    sent_at?: string;
    status?: string;
    subject?: string;
    to?: Array<string>;
};

export type EmailProviderMeta = {
    config_schema?: EmailConfigSchema;
    display_name?: string;
    provider?: string;
};

export type EmailProviderResponse = {
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    name?: string;
    provider?: string;
    updated_at?: string;
};

export type EmailUpdateBindingRequest = {
    can_delete?: boolean;
    can_read?: boolean;
    can_write?: boolean;
    config?: {
        [key: string]: unknown;
    };
    email_address?: string;
};

export type EmailUpdateProviderRequest = {
    config?: {
        [key: string]: unknown;
    };
    name?: string;
    provider?: string;
};

export type GithubComMemohaiMemohInternalMcpConnection = {
    auth_type?: string;
    bot_id?: string;
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    is_active?: boolean;
    last_probed_at?: string;
    name?: string;
    status?: string;
    status_message?: string;
    tools_cache?: Array<McpToolDescriptor>;
    type?: string;
    updated_at?: string;
};

export type HandlersBatchDeleteRequest = {
    ids?: Array<string>;
};

export type HandlersBrowserCoresResponse = {
    cores?: Array<string>;
};

export type HandlersChannelMeta = {
    capabilities?: ChannelChannelCapabilities;
    config_schema?: ChannelConfigSchema;
    configless?: boolean;
    display_name?: string;
    target_spec?: ChannelTargetSpec;
    type?: string;
    user_config_schema?: ChannelConfigSchema;
};

export type HandlersCreateContainerRequest = {
    image?: string;
    restore_data?: boolean;
    snapshotter?: string;
};

export type HandlersCreateContainerResponse = {
    container_id?: string;
    data_restored?: boolean;
    has_preserved_data?: boolean;
    image?: string;
    snapshotter?: string;
    started?: boolean;
};

export type HandlersCreateSnapshotRequest = {
    snapshot_name?: string;
};

export type HandlersCreateSnapshotResponse = {
    container_id?: string;
    display_name?: string;
    runtime_snapshot_name?: string;
    snapshot_name?: string;
    snapshotter?: string;
    source?: string;
    version?: number;
};

export type HandlersDailyTokenUsage = {
    cache_read_tokens?: number;
    cache_write_tokens?: number;
    day?: string;
    input_tokens?: number;
    output_tokens?: number;
    reasoning_tokens?: number;
};

export type HandlersErrorResponse = {
    message?: string;
};

export type HandlersFsDeleteRequest = {
    path?: string;
    recursive?: boolean;
};

export type HandlersFsFileInfo = {
    isDir?: boolean;
    modTime?: string;
    mode?: string;
    name?: string;
    path?: string;
    size?: number;
};

export type HandlersFsListResponse = {
    entries?: Array<HandlersFsFileInfo>;
    path?: string;
};

export type HandlersFsMkdirRequest = {
    path?: string;
};

export type HandlersFsReadResponse = {
    content?: string;
    path?: string;
    size?: number;
};

export type HandlersFsRenameRequest = {
    newPath?: string;
    oldPath?: string;
};

export type HandlersFsUploadResponse = {
    path?: string;
    size?: number;
};

export type HandlersFsWriteRequest = {
    content?: string;
    path?: string;
};

export type HandlersGetContainerResponse = {
    container_id?: string;
    container_path?: string;
    created_at?: string;
    has_preserved_data?: boolean;
    image?: string;
    legacy?: boolean;
    namespace?: string;
    status?: string;
    task_running?: boolean;
    updated_at?: string;
};

export type HandlersListSnapshotsResponse = {
    snapshots?: Array<HandlersSnapshotInfo>;
    snapshotter?: string;
};

export type HandlersLocalChannelMessageRequest = {
    message?: ChannelMessage;
};

export type HandlersLoginRequest = {
    password?: string;
    username?: string;
};

export type HandlersLoginResponse = {
    access_token?: string;
    display_name?: string;
    expires_at?: string;
    role?: string;
    token_type?: string;
    user_id?: string;
    username?: string;
};

export type HandlersMcpStdioRequest = {
    args?: Array<string>;
    command?: string;
    cwd?: string;
    env?: {
        [key: string]: string;
    };
    name?: string;
};

export type HandlersMcpStdioResponse = {
    connection_id?: string;
    tools?: Array<string>;
    url?: string;
};

export type HandlersModelTokenUsage = {
    input_tokens?: number;
    model_id?: string;
    model_name?: string;
    model_slug?: string;
    output_tokens?: number;
    provider_name?: string;
};

export type HandlersPingResponse = {
    container_backend?: string;
    snapshot_supported?: boolean;
    status?: string;
};

export type HandlersProbeResponse = {
    auth_required?: boolean;
    error?: string;
    status?: string;
    tools?: Array<McpToolDescriptor>;
};

export type HandlersRefreshResponse = {
    access_token?: string;
    expires_at?: string;
    token_type?: string;
};

export type HandlersRollbackRequest = {
    version?: number;
};

export type HandlersSkillItem = {
    content?: string;
    description?: string;
    metadata?: {
        [key: string]: unknown;
    };
    name?: string;
    raw?: string;
};

export type HandlersSkillsDeleteRequest = {
    names?: Array<string>;
};

export type HandlersSkillsResponse = {
    skills?: Array<HandlersSkillItem>;
};

export type HandlersSkillsUpsertRequest = {
    skills?: Array<string>;
};

export type HandlersSnapshotInfo = {
    created_at?: string;
    display_name?: string;
    kind?: string;
    labels?: {
        [key: string]: string;
    };
    managed?: boolean;
    name?: string;
    parent?: string;
    runtime_snapshot_name?: string;
    snapshotter?: string;
    source?: string;
    updated_at?: string;
    version?: number;
};

export type HandlersTokenUsageResponse = {
    by_model?: Array<HandlersModelTokenUsage>;
    chat?: Array<HandlersDailyTokenUsage>;
    heartbeat?: Array<HandlersDailyTokenUsage>;
    schedule?: Array<HandlersDailyTokenUsage>;
};

export type HandlersCreateSessionRequest = {
    channel_type?: string;
    metadata?: {
        [key: string]: unknown;
    };
    title?: string;
};

export type HandlersEmailOAuthStatusResponse = {
    configured?: boolean;
    email_address?: string;
    expired?: boolean;
    expires_at?: string;
    has_token?: boolean;
    provider?: string;
};

export type HandlersFsOpResponse = {
    ok?: boolean;
};

export type HandlersListMyIdentitiesResponse = {
    items?: Array<IdentitiesChannelIdentity>;
    user_id?: string;
};

export type HandlersMemoryAddPayload = {
    embedding_enabled?: boolean;
    filters?: {
        [key: string]: unknown;
    };
    infer?: boolean;
    message?: string;
    messages?: Array<AdaptersMessage>;
    metadata?: {
        [key: string]: unknown;
    };
    namespace?: string;
    run_id?: string;
};

export type HandlersMemoryCompactPayload = {
    decay_days?: number;
    ratio?: number;
};

export type HandlersMemoryDeletePayload = {
    memory_ids?: Array<string>;
};

export type HandlersMemorySearchPayload = {
    embedding_enabled?: boolean;
    filters?: {
        [key: string]: unknown;
    };
    limit?: number;
    no_stats?: boolean;
    query?: string;
    run_id?: string;
    sources?: Array<string>;
};

export type HandlersOauthAuthorizeRequest = {
    callback_url?: string;
    client_id?: string;
    client_secret?: string;
};

export type HandlersOauthDiscoverRequest = {
    url?: string;
};

export type HandlersOauthExchangeRequest = {
    code?: string;
    state?: string;
};

export type HandlersSkillsOpResponse = {
    ok?: boolean;
};

export type HandlersSynthesizeRequest = {
    text?: string;
};

export type HandlersSynthesizeResponse = {
    content_type?: string;
    size?: number;
    temp_id?: string;
};

export type HandlersTerminalInfoResponse = {
    available?: boolean;
    shell?: string;
};

export type HandlersUpdateSessionRequest = {
    metadata?: {
        [key: string]: unknown;
    };
    title?: string;
};

export type HeartbeatListLogsResponse = {
    items?: Array<HeartbeatLog>;
};

export type HeartbeatLog = {
    bot_id?: string;
    completed_at?: string;
    error_message?: string;
    id?: string;
    result_text?: string;
    session_id?: string;
    started_at?: string;
    status?: string;
    usage?: unknown;
};

export type IdentitiesChannelIdentity = {
    avatar_url?: string;
    channel?: string;
    channel_subject_id?: string;
    created_at?: string;
    display_name?: string;
    id?: string;
    metadata?: {
        [key: string]: unknown;
    };
    updated_at?: string;
    user_id?: string;
};

export type McpAuthorizeResult = {
    authorization_url?: string;
};

export type McpDiscoveryResult = {
    authorization_endpoint?: string;
    authorization_server_url?: string;
    registration_endpoint?: string;
    resource_metadata_url?: string;
    resource_uri?: string;
    scopes_supported?: Array<string>;
    token_endpoint?: string;
};

export type McpExportResponse = {
    mcpServers?: {
        [key: string]: McpMcpServerEntry;
    };
};

export type McpImportRequest = {
    mcpServers?: {
        [key: string]: McpMcpServerEntry;
    };
};

export type McpListResponse = {
    items?: Array<GithubComMemohaiMemohInternalMcpConnection>;
};

export type McpMcpServerEntry = {
    args?: Array<string>;
    command?: string;
    cwd?: string;
    env?: {
        [key: string]: string;
    };
    headers?: {
        [key: string]: string;
    };
    transport?: string;
    url?: string;
};

export type McpOAuthStatus = {
    auth_server?: string;
    callback_url?: string;
    configured?: boolean;
    expired?: boolean;
    expires_at?: string;
    has_token?: boolean;
    scopes?: string;
};

export type McpToolDescriptor = {
    description?: string;
    inputSchema?: {
        [key: string]: unknown;
    };
    name?: string;
};

export type McpUpsertRequest = {
    args?: Array<string>;
    auth_type?: string;
    command?: string;
    cwd?: string;
    env?: {
        [key: string]: string;
    };
    headers?: {
        [key: string]: string;
    };
    is_active?: boolean;
    name?: string;
    transport?: string;
    url?: string;
};

export type MessageMessage = {
    assets?: Array<MessageMessageAsset>;
    bot_id?: string;
    compact_id?: string;
    content?: Array<number>;
    created_at?: string;
    external_message_id?: string;
    id?: string;
    metadata?: {
        [key: string]: unknown;
    };
    platform?: string;
    role?: string;
    sender_avatar_url?: string;
    sender_channel_identity_id?: string;
    sender_display_name?: string;
    sender_user_id?: string;
    session_id?: string;
    source_reply_to_message_id?: string;
    usage?: Array<number>;
};

export type MessageMessageAsset = {
    content_hash?: string;
    metadata?: {
        [key: string]: unknown;
    };
    mime?: string;
    name?: string;
    ordinal?: number;
    role?: string;
    size_bytes?: number;
    storage_key?: string;
};

export type ModelsAddRequest = {
    config?: ModelsModelConfig;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

export type ModelsAddResponse = {
    id?: string;
    model_id?: string;
};

export type ModelsCountResponse = {
    count?: number;
};

export type ModelsGetResponse = {
    config?: ModelsModelConfig;
    id?: string;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

export type ModelsModelConfig = {
    compatibilities?: Array<string>;
    context_window?: number;
    dimensions?: number;
};

export type ModelsModelType = 'chat' | 'embedding';

export type ModelsTestResponse = {
    latency_ms?: number;
    message?: string;
    reachable?: boolean;
    status?: ModelsTestStatus;
};

export type ModelsTestStatus = 'ok' | 'auth_error' | 'model_not_supported' | 'error';

export type ModelsUpdateRequest = {
    config?: ModelsModelConfig;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

export type ProvidersCountResponse = {
    count?: number;
};

export type ProvidersCreateRequest = {
    api_key?: string;
    base_url: string;
    client_type: string;
    icon?: string;
    metadata?: {
        [key: string]: unknown;
    };
    name: string;
};

export type ProvidersGetResponse = {
    api_key?: string;
    base_url?: string;
    client_type?: string;
    created_at?: string;
    enable?: boolean;
    icon?: string;
    id?: string;
    metadata?: {
        [key: string]: unknown;
    };
    name?: string;
    updated_at?: string;
};

export type ProvidersImportModelsResponse = {
    created?: number;
    models?: Array<string>;
    skipped?: number;
};

export type ProvidersTestResponse = {
    latency_ms?: number;
    message?: string;
    reachable?: boolean;
};

export type ProvidersUpdateRequest = {
    api_key?: string;
    base_url?: string;
    client_type?: string;
    enable?: boolean;
    icon?: string;
    metadata?: {
        [key: string]: unknown;
    };
    name?: string;
};

export type ScheduleCreateRequest = {
    command?: string;
    description?: string;
    enabled?: boolean;
    max_calls?: ScheduleNullableInt;
    name?: string;
    pattern?: string;
};

export type ScheduleListLogsResponse = {
    items?: Array<ScheduleLog>;
};

export type ScheduleListResponse = {
    items?: Array<ScheduleSchedule>;
};

export type ScheduleLog = {
    bot_id?: string;
    completed_at?: string;
    error_message?: string;
    id?: string;
    result_text?: string;
    schedule_id?: string;
    session_id?: string;
    started_at?: string;
    status?: string;
    usage?: unknown;
};

export type ScheduleNullableInt = {
    set?: boolean;
    value?: number;
};

export type ScheduleSchedule = {
    bot_id?: string;
    command?: string;
    created_at?: string;
    current_calls?: number;
    description?: string;
    enabled?: boolean;
    id?: string;
    max_calls?: number;
    name?: string;
    pattern?: string;
    updated_at?: string;
};

export type ScheduleUpdateRequest = {
    command?: string;
    description?: string;
    enabled?: boolean;
    max_calls?: ScheduleNullableInt;
    name?: string;
    pattern?: string;
};

export type SearchprovidersCreateRequest = {
    config?: {
        [key: string]: unknown;
    };
    name?: string;
    provider?: SearchprovidersProviderName;
};

export type SearchprovidersGetResponse = {
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    name?: string;
    provider?: string;
    updated_at?: string;
};

export type SearchprovidersProviderConfigSchema = {
    fields?: {
        [key: string]: SearchprovidersProviderFieldSchema;
    };
};

export type SearchprovidersProviderFieldSchema = {
    description?: string;
    enum?: Array<string>;
    example?: unknown;
    required?: boolean;
    title?: string;
    type?: string;
};

export type SearchprovidersProviderMeta = {
    config_schema?: SearchprovidersProviderConfigSchema;
    display_name?: string;
    provider?: string;
};

export type SearchprovidersProviderName = 'brave' | 'bing' | 'google' | 'tavily' | 'sogou' | 'serper' | 'searxng' | 'jina' | 'exa' | 'bocha' | 'duckduckgo' | 'yandex';

export type SearchprovidersUpdateRequest = {
    config?: {
        [key: string]: unknown;
    };
    name?: string;
    provider?: SearchprovidersProviderName;
};

export type SessionSession = {
    bot_id?: string;
    channel_type?: string;
    created_at?: string;
    id?: string;
    metadata?: {
        [key: string]: unknown;
    };
    parent_session_id?: string;
    route_conversation_type?: string;
    route_id?: string;
    route_metadata?: {
        [key: string]: unknown;
    };
    title?: string;
    type?: string;
    updated_at?: string;
};

export type SettingsSettings = {
    allow_guest?: boolean;
    browser_context_id?: string;
    chat_model_id?: string;
    compaction_enabled?: boolean;
    compaction_model_id?: string;
    compaction_threshold?: number;
    heartbeat_enabled?: boolean;
    heartbeat_interval?: number;
    heartbeat_model_id?: string;
    language?: string;
    max_context_load_time?: number;
    max_context_tokens?: number;
    memory_provider_id?: string;
    reasoning_effort?: string;
    reasoning_enabled?: boolean;
    search_provider_id?: string;
    title_model_id?: string;
    tts_model_id?: string;
};

export type SettingsUpsertRequest = {
    allow_guest?: boolean;
    browser_context_id?: string;
    chat_model_id?: string;
    compaction_enabled?: boolean;
    compaction_model_id?: string;
    compaction_threshold?: number;
    heartbeat_enabled?: boolean;
    heartbeat_interval?: number;
    heartbeat_model_id?: string;
    language?: string;
    max_context_load_time?: number;
    max_context_tokens?: number;
    memory_provider_id?: string;
    reasoning_effort?: string;
    reasoning_enabled?: boolean;
    search_provider_id?: string;
    title_model_id?: string;
    tts_model_id?: string;
};

export type TtsCreateModelRequest = {
    config?: {
        [key: string]: unknown;
    };
    model_id?: string;
    name?: string;
    tts_provider_id?: string;
};

export type TtsCreateProviderRequest = {
    name?: string;
    provider?: string;
};

export type TtsModelCapabilities = {
    formats?: Array<string>;
    pitch?: TtsParamConstraint;
    speed?: TtsParamConstraint;
    voices?: Array<TtsVoiceInfo>;
};

export type TtsModelInfo = {
    capabilities?: TtsModelCapabilities;
    description?: string;
    id?: string;
    name?: string;
};

export type TtsModelResponse = {
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    model_id?: string;
    name?: string;
    provider_type?: string;
    tts_provider_id?: string;
    updated_at?: string;
};

export type TtsParamConstraint = {
    default?: number;
    max?: number;
    min?: number;
    options?: Array<number>;
};

export type TtsProviderMetaResponse = {
    default_model?: string;
    description?: string;
    display_name?: string;
    models?: Array<TtsModelInfo>;
    provider?: string;
};

export type TtsProviderResponse = {
    created_at?: string;
    id?: string;
    name?: string;
    provider?: string;
    updated_at?: string;
};

export type TtsTestSynthesizeRequest = {
    config?: {
        [key: string]: unknown;
    };
    text?: string;
};

export type TtsUpdateModelRequest = {
    config?: {
        [key: string]: unknown;
    };
    name?: string;
};

export type TtsUpdateProviderRequest = {
    name?: string;
};

export type TtsVoiceInfo = {
    id?: string;
    lang?: string;
    name?: string;
};

export type PostAuthLoginData = {
    /**
     * Login request
     */
    body: HandlersLoginRequest;
    path?: never;
    query?: never;
    url: '/auth/login';
};

export type PostAuthLoginErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Unauthorized
     */
    401: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostAuthLoginError = PostAuthLoginErrors[keyof PostAuthLoginErrors];

export type PostAuthLoginResponses = {
    /**
     * OK
     */
    200: HandlersLoginResponse;
};

export type PostAuthLoginResponse = PostAuthLoginResponses[keyof PostAuthLoginResponses];

export type PostAuthRefreshData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/auth/refresh';
};

export type PostAuthRefreshErrors = {
    /**
     * Unauthorized
     */
    401: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostAuthRefreshError = PostAuthRefreshErrors[keyof PostAuthRefreshErrors];

export type PostAuthRefreshResponses = {
    /**
     * OK
     */
    200: HandlersRefreshResponse;
};

export type PostAuthRefreshResponse = PostAuthRefreshResponses[keyof PostAuthRefreshResponses];

export type GetBotsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Owner user ID (admin only)
         */
        owner_id?: string;
    };
    url: '/bots';
};

export type GetBotsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsError = GetBotsErrors[keyof GetBotsErrors];

export type GetBotsResponses = {
    /**
     * OK
     */
    200: BotsListBotsResponse;
};

export type GetBotsResponse = GetBotsResponses[keyof GetBotsResponses];

export type PostBotsData = {
    /**
     * Bot payload
     */
    body: BotsCreateBotRequest;
    path?: never;
    query?: never;
    url: '/bots';
};

export type PostBotsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsError = PostBotsErrors[keyof PostBotsErrors];

export type PostBotsResponses = {
    /**
     * Created
     */
    201: BotsBot;
};

export type PostBotsResponse = PostBotsResponses[keyof PostBotsResponses];

export type GetBotsByBotIdAccessChannelIdentitiesData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Search query
         */
        q?: string;
        /**
         * Max results
         */
        limit?: number;
    };
    url: '/bots/{bot_id}/access/channel_identities';
};

export type GetBotsByBotIdAccessChannelIdentitiesErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdAccessChannelIdentitiesError = GetBotsByBotIdAccessChannelIdentitiesErrors[keyof GetBotsByBotIdAccessChannelIdentitiesErrors];

export type GetBotsByBotIdAccessChannelIdentitiesResponses = {
    /**
     * OK
     */
    200: AclChannelIdentityCandidateListResponse;
};

export type GetBotsByBotIdAccessChannelIdentitiesResponse = GetBotsByBotIdAccessChannelIdentitiesResponses[keyof GetBotsByBotIdAccessChannelIdentitiesResponses];

export type GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Channel Identity ID
         */
        channel_identity_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/access/channel_identities/{channel_identity_id}/conversations';
};

export type GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsError = GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsErrors[keyof GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsErrors];

export type GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsResponses = {
    /**
     * OK
     */
    200: AclObservedConversationCandidateListResponse;
};

export type GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsResponse = GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsResponses[keyof GetBotsByBotIdAccessChannelIdentitiesByChannelIdentityIdConversationsResponses];

export type GetBotsByBotIdAccessUsersData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Search query
         */
        q?: string;
        /**
         * Max results
         */
        limit?: number;
    };
    url: '/bots/{bot_id}/access/users';
};

export type GetBotsByBotIdAccessUsersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdAccessUsersError = GetBotsByBotIdAccessUsersErrors[keyof GetBotsByBotIdAccessUsersErrors];

export type GetBotsByBotIdAccessUsersResponses = {
    /**
     * OK
     */
    200: AclUserCandidateListResponse;
};

export type GetBotsByBotIdAccessUsersResponse = GetBotsByBotIdAccessUsersResponses[keyof GetBotsByBotIdAccessUsersResponses];

export type GetBotsByBotIdBlacklistData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/blacklist';
};

export type GetBotsByBotIdBlacklistErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdBlacklistError = GetBotsByBotIdBlacklistErrors[keyof GetBotsByBotIdBlacklistErrors];

export type GetBotsByBotIdBlacklistResponses = {
    /**
     * OK
     */
    200: AclListRulesResponse;
};

export type GetBotsByBotIdBlacklistResponse = GetBotsByBotIdBlacklistResponses[keyof GetBotsByBotIdBlacklistResponses];

export type PutBotsByBotIdBlacklistData = {
    /**
     * Blacklist payload
     */
    body: AclUpsertRuleRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/blacklist';
};

export type PutBotsByBotIdBlacklistErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByBotIdBlacklistError = PutBotsByBotIdBlacklistErrors[keyof PutBotsByBotIdBlacklistErrors];

export type PutBotsByBotIdBlacklistResponses = {
    /**
     * OK
     */
    200: AclRule;
};

export type PutBotsByBotIdBlacklistResponse = PutBotsByBotIdBlacklistResponses[keyof PutBotsByBotIdBlacklistResponses];

export type DeleteBotsByBotIdBlacklistByRuleIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Rule ID
         */
        rule_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/blacklist/{rule_id}';
};

export type DeleteBotsByBotIdBlacklistByRuleIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdBlacklistByRuleIdError = DeleteBotsByBotIdBlacklistByRuleIdErrors[keyof DeleteBotsByBotIdBlacklistByRuleIdErrors];

export type DeleteBotsByBotIdBlacklistByRuleIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type PostBotsByBotIdCliMessagesData = {
    /**
     * Message payload
     */
    body: HandlersLocalChannelMessageRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/cli/messages';
};

export type PostBotsByBotIdCliMessagesErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdCliMessagesError = PostBotsByBotIdCliMessagesErrors[keyof PostBotsByBotIdCliMessagesErrors];

export type PostBotsByBotIdCliMessagesResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: string;
    };
};

export type PostBotsByBotIdCliMessagesResponse = PostBotsByBotIdCliMessagesResponses[keyof PostBotsByBotIdCliMessagesResponses];

export type GetBotsByBotIdCliStreamData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/cli/stream';
};

export type GetBotsByBotIdCliStreamErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdCliStreamError = GetBotsByBotIdCliStreamErrors[keyof GetBotsByBotIdCliStreamErrors];

export type GetBotsByBotIdCliStreamResponses = {
    /**
     * SSE stream
     */
    200: string;
};

export type GetBotsByBotIdCliStreamResponse = GetBotsByBotIdCliStreamResponses[keyof GetBotsByBotIdCliStreamResponses];

export type GetBotsByBotIdCliWsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/cli/ws';
};

export type GetBotsByBotIdCliWsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdCliWsError = GetBotsByBotIdCliWsErrors[keyof GetBotsByBotIdCliWsErrors];

export type DeleteBotsByBotIdCompactionLogsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/compaction/logs';
};

export type DeleteBotsByBotIdCompactionLogsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdCompactionLogsError = DeleteBotsByBotIdCompactionLogsErrors[keyof DeleteBotsByBotIdCompactionLogsErrors];

export type DeleteBotsByBotIdCompactionLogsResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdCompactionLogsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Before timestamp (RFC3339)
         */
        before?: string;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/bots/{bot_id}/compaction/logs';
};

export type GetBotsByBotIdCompactionLogsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdCompactionLogsError = GetBotsByBotIdCompactionLogsErrors[keyof GetBotsByBotIdCompactionLogsErrors];

export type GetBotsByBotIdCompactionLogsResponses = {
    /**
     * OK
     */
    200: CompactionListLogsResponse;
};

export type GetBotsByBotIdCompactionLogsResponse = GetBotsByBotIdCompactionLogsResponses[keyof GetBotsByBotIdCompactionLogsResponses];

export type DeleteBotsByBotIdContainerData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Export /data before deletion
         */
        preserve_data?: boolean;
    };
    url: '/bots/{bot_id}/container';
};

export type DeleteBotsByBotIdContainerErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdContainerError = DeleteBotsByBotIdContainerErrors[keyof DeleteBotsByBotIdContainerErrors];

export type DeleteBotsByBotIdContainerResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdContainerData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container';
};

export type GetBotsByBotIdContainerErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerError = GetBotsByBotIdContainerErrors[keyof GetBotsByBotIdContainerErrors];

export type GetBotsByBotIdContainerResponses = {
    /**
     * OK
     */
    200: HandlersGetContainerResponse;
};

export type GetBotsByBotIdContainerResponse = GetBotsByBotIdContainerResponses[keyof GetBotsByBotIdContainerResponses];

export type PostBotsByBotIdContainerData = {
    /**
     * Create container payload
     */
    body: HandlersCreateContainerRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container';
};

export type PostBotsByBotIdContainerErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerError = PostBotsByBotIdContainerErrors[keyof PostBotsByBotIdContainerErrors];

export type PostBotsByBotIdContainerResponses = {
    /**
     * SSE stream of container creation events
     */
    200: HandlersCreateContainerResponse;
};

export type PostBotsByBotIdContainerResponse = PostBotsByBotIdContainerResponses[keyof PostBotsByBotIdContainerResponses];

export type PostBotsByBotIdContainerDataExportData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/data/export';
};

export type PostBotsByBotIdContainerDataExportErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerDataExportError = PostBotsByBotIdContainerDataExportErrors[keyof PostBotsByBotIdContainerDataExportErrors];

export type PostBotsByBotIdContainerDataExportResponses = {
    /**
     * OK
     */
    200: unknown;
};

export type PostBotsByBotIdContainerDataImportData = {
    body: {
        /**
         * tar.gz archive
         */
        file: Blob | File;
    };
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/data/import';
};

export type PostBotsByBotIdContainerDataImportErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerDataImportError = PostBotsByBotIdContainerDataImportErrors[keyof PostBotsByBotIdContainerDataImportErrors];

export type PostBotsByBotIdContainerDataImportResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: unknown;
    };
};

export type PostBotsByBotIdContainerDataImportResponse = PostBotsByBotIdContainerDataImportResponses[keyof PostBotsByBotIdContainerDataImportResponses];

export type PostBotsByBotIdContainerDataRestoreData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/data/restore';
};

export type PostBotsByBotIdContainerDataRestoreErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerDataRestoreError = PostBotsByBotIdContainerDataRestoreErrors[keyof PostBotsByBotIdContainerDataRestoreErrors];

export type PostBotsByBotIdContainerDataRestoreResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: unknown;
    };
};

export type PostBotsByBotIdContainerDataRestoreResponse = PostBotsByBotIdContainerDataRestoreResponses[keyof PostBotsByBotIdContainerDataRestoreResponses];

export type GetBotsByBotIdContainerFsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query: {
        /**
         * Container path
         */
        path: string;
    };
    url: '/bots/{bot_id}/container/fs';
};

export type GetBotsByBotIdContainerFsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerFsError = GetBotsByBotIdContainerFsErrors[keyof GetBotsByBotIdContainerFsErrors];

export type GetBotsByBotIdContainerFsResponses = {
    /**
     * OK
     */
    200: HandlersFsFileInfo;
};

export type GetBotsByBotIdContainerFsResponse = GetBotsByBotIdContainerFsResponses[keyof GetBotsByBotIdContainerFsResponses];

export type PostBotsByBotIdContainerFsDeleteData = {
    /**
     * Delete request
     */
    body: HandlersFsDeleteRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/fs/delete';
};

export type PostBotsByBotIdContainerFsDeleteErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerFsDeleteError = PostBotsByBotIdContainerFsDeleteErrors[keyof PostBotsByBotIdContainerFsDeleteErrors];

export type PostBotsByBotIdContainerFsDeleteResponses = {
    /**
     * OK
     */
    200: HandlersFsOpResponse;
};

export type PostBotsByBotIdContainerFsDeleteResponse = PostBotsByBotIdContainerFsDeleteResponses[keyof PostBotsByBotIdContainerFsDeleteResponses];

export type GetBotsByBotIdContainerFsDownloadData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query: {
        /**
         * Container file path
         */
        path: string;
    };
    url: '/bots/{bot_id}/container/fs/download';
};

export type GetBotsByBotIdContainerFsDownloadErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerFsDownloadError = GetBotsByBotIdContainerFsDownloadErrors[keyof GetBotsByBotIdContainerFsDownloadErrors];

export type GetBotsByBotIdContainerFsDownloadResponses = {
    /**
     * OK
     */
    200: unknown;
};

export type GetBotsByBotIdContainerFsListData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query: {
        /**
         * Container directory path
         */
        path: string;
    };
    url: '/bots/{bot_id}/container/fs/list';
};

export type GetBotsByBotIdContainerFsListErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerFsListError = GetBotsByBotIdContainerFsListErrors[keyof GetBotsByBotIdContainerFsListErrors];

export type GetBotsByBotIdContainerFsListResponses = {
    /**
     * OK
     */
    200: HandlersFsListResponse;
};

export type GetBotsByBotIdContainerFsListResponse = GetBotsByBotIdContainerFsListResponses[keyof GetBotsByBotIdContainerFsListResponses];

export type PostBotsByBotIdContainerFsMkdirData = {
    /**
     * Mkdir request
     */
    body: HandlersFsMkdirRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/fs/mkdir';
};

export type PostBotsByBotIdContainerFsMkdirErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerFsMkdirError = PostBotsByBotIdContainerFsMkdirErrors[keyof PostBotsByBotIdContainerFsMkdirErrors];

export type PostBotsByBotIdContainerFsMkdirResponses = {
    /**
     * OK
     */
    200: HandlersFsOpResponse;
};

export type PostBotsByBotIdContainerFsMkdirResponse = PostBotsByBotIdContainerFsMkdirResponses[keyof PostBotsByBotIdContainerFsMkdirResponses];

export type GetBotsByBotIdContainerFsReadData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query: {
        /**
         * Container file path
         */
        path: string;
    };
    url: '/bots/{bot_id}/container/fs/read';
};

export type GetBotsByBotIdContainerFsReadErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerFsReadError = GetBotsByBotIdContainerFsReadErrors[keyof GetBotsByBotIdContainerFsReadErrors];

export type GetBotsByBotIdContainerFsReadResponses = {
    /**
     * OK
     */
    200: HandlersFsReadResponse;
};

export type GetBotsByBotIdContainerFsReadResponse = GetBotsByBotIdContainerFsReadResponses[keyof GetBotsByBotIdContainerFsReadResponses];

export type PostBotsByBotIdContainerFsRenameData = {
    /**
     * Rename request
     */
    body: HandlersFsRenameRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/fs/rename';
};

export type PostBotsByBotIdContainerFsRenameErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerFsRenameError = PostBotsByBotIdContainerFsRenameErrors[keyof PostBotsByBotIdContainerFsRenameErrors];

export type PostBotsByBotIdContainerFsRenameResponses = {
    /**
     * OK
     */
    200: HandlersFsOpResponse;
};

export type PostBotsByBotIdContainerFsRenameResponse = PostBotsByBotIdContainerFsRenameResponses[keyof PostBotsByBotIdContainerFsRenameResponses];

export type PostBotsByBotIdContainerFsUploadData = {
    body: {
        /**
         * Destination container path
         */
        path: string;
        /**
         * File to upload
         */
        file: Blob | File;
    };
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/fs/upload';
};

export type PostBotsByBotIdContainerFsUploadErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerFsUploadError = PostBotsByBotIdContainerFsUploadErrors[keyof PostBotsByBotIdContainerFsUploadErrors];

export type PostBotsByBotIdContainerFsUploadResponses = {
    /**
     * OK
     */
    200: HandlersFsUploadResponse;
};

export type PostBotsByBotIdContainerFsUploadResponse = PostBotsByBotIdContainerFsUploadResponses[keyof PostBotsByBotIdContainerFsUploadResponses];

export type PostBotsByBotIdContainerFsWriteData = {
    /**
     * Write request
     */
    body: HandlersFsWriteRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/fs/write';
};

export type PostBotsByBotIdContainerFsWriteErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerFsWriteError = PostBotsByBotIdContainerFsWriteErrors[keyof PostBotsByBotIdContainerFsWriteErrors];

export type PostBotsByBotIdContainerFsWriteResponses = {
    /**
     * OK
     */
    200: HandlersFsOpResponse;
};

export type PostBotsByBotIdContainerFsWriteResponse = PostBotsByBotIdContainerFsWriteResponses[keyof PostBotsByBotIdContainerFsWriteResponses];

export type DeleteBotsByBotIdContainerSkillsData = {
    /**
     * Delete skills payload
     */
    body: HandlersSkillsDeleteRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/skills';
};

export type DeleteBotsByBotIdContainerSkillsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdContainerSkillsError = DeleteBotsByBotIdContainerSkillsErrors[keyof DeleteBotsByBotIdContainerSkillsErrors];

export type DeleteBotsByBotIdContainerSkillsResponses = {
    /**
     * OK
     */
    200: HandlersSkillsOpResponse;
};

export type DeleteBotsByBotIdContainerSkillsResponse = DeleteBotsByBotIdContainerSkillsResponses[keyof DeleteBotsByBotIdContainerSkillsResponses];

export type GetBotsByBotIdContainerSkillsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/skills';
};

export type GetBotsByBotIdContainerSkillsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerSkillsError = GetBotsByBotIdContainerSkillsErrors[keyof GetBotsByBotIdContainerSkillsErrors];

export type GetBotsByBotIdContainerSkillsResponses = {
    /**
     * OK
     */
    200: HandlersSkillsResponse;
};

export type GetBotsByBotIdContainerSkillsResponse = GetBotsByBotIdContainerSkillsResponses[keyof GetBotsByBotIdContainerSkillsResponses];

export type PostBotsByBotIdContainerSkillsData = {
    /**
     * Skills payload
     */
    body: HandlersSkillsUpsertRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/skills';
};

export type PostBotsByBotIdContainerSkillsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerSkillsError = PostBotsByBotIdContainerSkillsErrors[keyof PostBotsByBotIdContainerSkillsErrors];

export type PostBotsByBotIdContainerSkillsResponses = {
    /**
     * OK
     */
    200: HandlersSkillsOpResponse;
};

export type PostBotsByBotIdContainerSkillsResponse = PostBotsByBotIdContainerSkillsResponses[keyof PostBotsByBotIdContainerSkillsResponses];

export type GetBotsByBotIdContainerSnapshotsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Snapshotter name
         */
        snapshotter?: string;
    };
    url: '/bots/{bot_id}/container/snapshots';
};

export type GetBotsByBotIdContainerSnapshotsErrors = {
    /**
     * Snapshots currently not supported on this backend
     */
    501: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerSnapshotsError = GetBotsByBotIdContainerSnapshotsErrors[keyof GetBotsByBotIdContainerSnapshotsErrors];

export type GetBotsByBotIdContainerSnapshotsResponses = {
    /**
     * OK
     */
    200: HandlersListSnapshotsResponse;
};

export type GetBotsByBotIdContainerSnapshotsResponse = GetBotsByBotIdContainerSnapshotsResponses[keyof GetBotsByBotIdContainerSnapshotsResponses];

export type PostBotsByBotIdContainerSnapshotsData = {
    /**
     * Create snapshot payload
     */
    body: HandlersCreateSnapshotRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/snapshots';
};

export type PostBotsByBotIdContainerSnapshotsErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Snapshots currently not supported on this backend
     */
    501: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerSnapshotsError = PostBotsByBotIdContainerSnapshotsErrors[keyof PostBotsByBotIdContainerSnapshotsErrors];

export type PostBotsByBotIdContainerSnapshotsResponses = {
    /**
     * OK
     */
    200: HandlersCreateSnapshotResponse;
};

export type PostBotsByBotIdContainerSnapshotsResponse = PostBotsByBotIdContainerSnapshotsResponses[keyof PostBotsByBotIdContainerSnapshotsResponses];

export type PostBotsByBotIdContainerSnapshotsRollbackData = {
    /**
     * Rollback payload
     */
    body: HandlersRollbackRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/snapshots/rollback';
};

export type PostBotsByBotIdContainerSnapshotsRollbackErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerSnapshotsRollbackError = PostBotsByBotIdContainerSnapshotsRollbackErrors[keyof PostBotsByBotIdContainerSnapshotsRollbackErrors];

export type PostBotsByBotIdContainerSnapshotsRollbackResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: unknown;
    };
};

export type PostBotsByBotIdContainerSnapshotsRollbackResponse = PostBotsByBotIdContainerSnapshotsRollbackResponses[keyof PostBotsByBotIdContainerSnapshotsRollbackResponses];

export type PostBotsByBotIdContainerStartData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/start';
};

export type PostBotsByBotIdContainerStartErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerStartError = PostBotsByBotIdContainerStartErrors[keyof PostBotsByBotIdContainerStartErrors];

export type PostBotsByBotIdContainerStartResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: unknown;
    };
};

export type PostBotsByBotIdContainerStartResponse = PostBotsByBotIdContainerStartResponses[keyof PostBotsByBotIdContainerStartResponses];

export type PostBotsByBotIdContainerStopData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/stop';
};

export type PostBotsByBotIdContainerStopErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdContainerStopError = PostBotsByBotIdContainerStopErrors[keyof PostBotsByBotIdContainerStopErrors];

export type PostBotsByBotIdContainerStopResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: unknown;
    };
};

export type PostBotsByBotIdContainerStopResponse = PostBotsByBotIdContainerStopResponses[keyof PostBotsByBotIdContainerStopResponses];

export type GetBotsByBotIdContainerTerminalData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/container/terminal';
};

export type GetBotsByBotIdContainerTerminalErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerTerminalError = GetBotsByBotIdContainerTerminalErrors[keyof GetBotsByBotIdContainerTerminalErrors];

export type GetBotsByBotIdContainerTerminalResponses = {
    /**
     * OK
     */
    200: HandlersTerminalInfoResponse;
};

export type GetBotsByBotIdContainerTerminalResponse = GetBotsByBotIdContainerTerminalResponses[keyof GetBotsByBotIdContainerTerminalResponses];

export type GetBotsByBotIdContainerTerminalWsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Initial terminal columns
         */
        cols?: number;
        /**
         * Initial terminal rows
         */
        rows?: number;
        /**
         * Auth token
         */
        token?: string;
    };
    url: '/bots/{bot_id}/container/terminal/ws';
};

export type GetBotsByBotIdContainerTerminalWsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdContainerTerminalWsError = GetBotsByBotIdContainerTerminalWsErrors[keyof GetBotsByBotIdContainerTerminalWsErrors];

export type GetBotsByBotIdEmailBindingsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/email-bindings';
};

export type GetBotsByBotIdEmailBindingsErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdEmailBindingsError = GetBotsByBotIdEmailBindingsErrors[keyof GetBotsByBotIdEmailBindingsErrors];

export type GetBotsByBotIdEmailBindingsResponses = {
    /**
     * OK
     */
    200: Array<EmailBindingResponse>;
};

export type GetBotsByBotIdEmailBindingsResponse = GetBotsByBotIdEmailBindingsResponses[keyof GetBotsByBotIdEmailBindingsResponses];

export type PostBotsByBotIdEmailBindingsData = {
    /**
     * Binding configuration
     */
    body: EmailCreateBindingRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/email-bindings';
};

export type PostBotsByBotIdEmailBindingsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdEmailBindingsError = PostBotsByBotIdEmailBindingsErrors[keyof PostBotsByBotIdEmailBindingsErrors];

export type PostBotsByBotIdEmailBindingsResponses = {
    /**
     * Created
     */
    201: EmailBindingResponse;
};

export type PostBotsByBotIdEmailBindingsResponse = PostBotsByBotIdEmailBindingsResponses[keyof PostBotsByBotIdEmailBindingsResponses];

export type DeleteBotsByBotIdEmailBindingsByIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Binding ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/email-bindings/{id}';
};

export type DeleteBotsByBotIdEmailBindingsByIdErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdEmailBindingsByIdError = DeleteBotsByBotIdEmailBindingsByIdErrors[keyof DeleteBotsByBotIdEmailBindingsByIdErrors];

export type DeleteBotsByBotIdEmailBindingsByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type PutBotsByBotIdEmailBindingsByIdData = {
    /**
     * Updated binding
     */
    body: EmailUpdateBindingRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Binding ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/email-bindings/{id}';
};

export type PutBotsByBotIdEmailBindingsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByBotIdEmailBindingsByIdError = PutBotsByBotIdEmailBindingsByIdErrors[keyof PutBotsByBotIdEmailBindingsByIdErrors];

export type PutBotsByBotIdEmailBindingsByIdResponses = {
    /**
     * OK
     */
    200: EmailBindingResponse;
};

export type PutBotsByBotIdEmailBindingsByIdResponse = PutBotsByBotIdEmailBindingsByIdResponses[keyof PutBotsByBotIdEmailBindingsByIdResponses];

export type GetBotsByBotIdEmailOutboxData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Limit
         */
        limit?: number;
        /**
         * Offset
         */
        offset?: number;
    };
    url: '/bots/{bot_id}/email-outbox';
};

export type GetBotsByBotIdEmailOutboxErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdEmailOutboxError = GetBotsByBotIdEmailOutboxErrors[keyof GetBotsByBotIdEmailOutboxErrors];

export type GetBotsByBotIdEmailOutboxResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: unknown;
    };
};

export type GetBotsByBotIdEmailOutboxResponse = GetBotsByBotIdEmailOutboxResponses[keyof GetBotsByBotIdEmailOutboxResponses];

export type GetBotsByBotIdEmailOutboxByIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Email ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/email-outbox/{id}';
};

export type GetBotsByBotIdEmailOutboxByIdErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetBotsByBotIdEmailOutboxByIdError = GetBotsByBotIdEmailOutboxByIdErrors[keyof GetBotsByBotIdEmailOutboxByIdErrors];

export type GetBotsByBotIdEmailOutboxByIdResponses = {
    /**
     * OK
     */
    200: EmailOutboxItemResponse;
};

export type GetBotsByBotIdEmailOutboxByIdResponse = GetBotsByBotIdEmailOutboxByIdResponses[keyof GetBotsByBotIdEmailOutboxByIdResponses];

export type DeleteBotsByBotIdHeartbeatLogsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/heartbeat/logs';
};

export type DeleteBotsByBotIdHeartbeatLogsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdHeartbeatLogsError = DeleteBotsByBotIdHeartbeatLogsErrors[keyof DeleteBotsByBotIdHeartbeatLogsErrors];

export type DeleteBotsByBotIdHeartbeatLogsResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdHeartbeatLogsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Before timestamp (RFC3339)
         */
        before?: string;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/bots/{bot_id}/heartbeat/logs';
};

export type GetBotsByBotIdHeartbeatLogsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdHeartbeatLogsError = GetBotsByBotIdHeartbeatLogsErrors[keyof GetBotsByBotIdHeartbeatLogsErrors];

export type GetBotsByBotIdHeartbeatLogsResponses = {
    /**
     * OK
     */
    200: HeartbeatListLogsResponse;
};

export type GetBotsByBotIdHeartbeatLogsResponse = GetBotsByBotIdHeartbeatLogsResponses[keyof GetBotsByBotIdHeartbeatLogsResponses];

export type GetBotsByBotIdMcpData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/mcp';
};

export type GetBotsByBotIdMcpErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdMcpError = GetBotsByBotIdMcpErrors[keyof GetBotsByBotIdMcpErrors];

export type GetBotsByBotIdMcpResponses = {
    /**
     * OK
     */
    200: McpListResponse;
};

export type GetBotsByBotIdMcpResponse = GetBotsByBotIdMcpResponses[keyof GetBotsByBotIdMcpResponses];

export type PostBotsByBotIdMcpData = {
    /**
     * MCP payload
     */
    body: McpUpsertRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/mcp';
};

export type PostBotsByBotIdMcpErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpError = PostBotsByBotIdMcpErrors[keyof PostBotsByBotIdMcpErrors];

export type PostBotsByBotIdMcpResponses = {
    /**
     * Created
     */
    201: GithubComMemohaiMemohInternalMcpConnection;
};

export type PostBotsByBotIdMcpResponse = PostBotsByBotIdMcpResponses[keyof PostBotsByBotIdMcpResponses];

export type PostBotsByBotIdMcpOpsBatchDeleteData = {
    /**
     * IDs to delete
     */
    body: HandlersBatchDeleteRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/mcp-ops/batch-delete';
};

export type PostBotsByBotIdMcpOpsBatchDeleteErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpOpsBatchDeleteError = PostBotsByBotIdMcpOpsBatchDeleteErrors[keyof PostBotsByBotIdMcpOpsBatchDeleteErrors];

export type PostBotsByBotIdMcpOpsBatchDeleteResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type PostBotsByBotIdMcpStdioData = {
    /**
     * Stdio MCP payload
     */
    body: HandlersMcpStdioRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp-stdio';
};

export type PostBotsByBotIdMcpStdioErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpStdioError = PostBotsByBotIdMcpStdioErrors[keyof PostBotsByBotIdMcpStdioErrors];

export type PostBotsByBotIdMcpStdioResponses = {
    /**
     * OK
     */
    200: HandlersMcpStdioResponse;
};

export type PostBotsByBotIdMcpStdioResponse = PostBotsByBotIdMcpStdioResponses[keyof PostBotsByBotIdMcpStdioResponses];

export type PostBotsByBotIdMcpStdioByConnectionIdData = {
    /**
     * JSON-RPC request
     */
    body: {
        [key: string]: unknown;
    };
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Connection ID
         */
        connection_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp-stdio/{connection_id}';
};

export type PostBotsByBotIdMcpStdioByConnectionIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpStdioByConnectionIdError = PostBotsByBotIdMcpStdioByConnectionIdErrors[keyof PostBotsByBotIdMcpStdioByConnectionIdErrors];

export type PostBotsByBotIdMcpStdioByConnectionIdResponses = {
    /**
     * JSON-RPC response: {jsonrpc,id,result|error}
     */
    200: {
        [key: string]: unknown;
    };
};

export type PostBotsByBotIdMcpStdioByConnectionIdResponse = PostBotsByBotIdMcpStdioByConnectionIdResponses[keyof PostBotsByBotIdMcpStdioByConnectionIdResponses];

export type GetBotsByBotIdMcpExportData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/mcp/export';
};

export type GetBotsByBotIdMcpExportErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdMcpExportError = GetBotsByBotIdMcpExportErrors[keyof GetBotsByBotIdMcpExportErrors];

export type GetBotsByBotIdMcpExportResponses = {
    /**
     * OK
     */
    200: McpExportResponse;
};

export type GetBotsByBotIdMcpExportResponse = GetBotsByBotIdMcpExportResponses[keyof GetBotsByBotIdMcpExportResponses];

export type PutBotsByBotIdMcpImportData = {
    /**
     * mcpServers dict
     */
    body: McpImportRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/mcp/import';
};

export type PutBotsByBotIdMcpImportErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByBotIdMcpImportError = PutBotsByBotIdMcpImportErrors[keyof PutBotsByBotIdMcpImportErrors];

export type PutBotsByBotIdMcpImportResponses = {
    /**
     * OK
     */
    200: McpListResponse;
};

export type PutBotsByBotIdMcpImportResponse = PutBotsByBotIdMcpImportResponses[keyof PutBotsByBotIdMcpImportResponses];

export type DeleteBotsByBotIdMcpByIdData = {
    body?: never;
    path: {
        /**
         * MCP ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}';
};

export type DeleteBotsByBotIdMcpByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdMcpByIdError = DeleteBotsByBotIdMcpByIdErrors[keyof DeleteBotsByBotIdMcpByIdErrors];

export type DeleteBotsByBotIdMcpByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdMcpByIdData = {
    body?: never;
    path: {
        /**
         * MCP ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}';
};

export type GetBotsByBotIdMcpByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdMcpByIdError = GetBotsByBotIdMcpByIdErrors[keyof GetBotsByBotIdMcpByIdErrors];

export type GetBotsByBotIdMcpByIdResponses = {
    /**
     * OK
     */
    200: GithubComMemohaiMemohInternalMcpConnection;
};

export type GetBotsByBotIdMcpByIdResponse = GetBotsByBotIdMcpByIdResponses[keyof GetBotsByBotIdMcpByIdResponses];

export type PutBotsByBotIdMcpByIdData = {
    /**
     * MCP payload
     */
    body: McpUpsertRequest;
    path: {
        /**
         * MCP ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}';
};

export type PutBotsByBotIdMcpByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByBotIdMcpByIdError = PutBotsByBotIdMcpByIdErrors[keyof PutBotsByBotIdMcpByIdErrors];

export type PutBotsByBotIdMcpByIdResponses = {
    /**
     * OK
     */
    200: GithubComMemohaiMemohInternalMcpConnection;
};

export type PutBotsByBotIdMcpByIdResponse = PutBotsByBotIdMcpByIdResponses[keyof PutBotsByBotIdMcpByIdResponses];

export type PostBotsByBotIdMcpByIdOauthAuthorizeData = {
    /**
     * Optional client_id
     */
    body?: HandlersOauthAuthorizeRequest;
    path: {
        /**
         * MCP connection ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}/oauth/authorize';
};

export type PostBotsByBotIdMcpByIdOauthAuthorizeErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpByIdOauthAuthorizeError = PostBotsByBotIdMcpByIdOauthAuthorizeErrors[keyof PostBotsByBotIdMcpByIdOauthAuthorizeErrors];

export type PostBotsByBotIdMcpByIdOauthAuthorizeResponses = {
    /**
     * OK
     */
    200: McpAuthorizeResult;
};

export type PostBotsByBotIdMcpByIdOauthAuthorizeResponse = PostBotsByBotIdMcpByIdOauthAuthorizeResponses[keyof PostBotsByBotIdMcpByIdOauthAuthorizeResponses];

export type PostBotsByBotIdMcpByIdOauthDiscoverData = {
    /**
     * Optional URL override
     */
    body?: HandlersOauthDiscoverRequest;
    path: {
        /**
         * MCP connection ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}/oauth/discover';
};

export type PostBotsByBotIdMcpByIdOauthDiscoverErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpByIdOauthDiscoverError = PostBotsByBotIdMcpByIdOauthDiscoverErrors[keyof PostBotsByBotIdMcpByIdOauthDiscoverErrors];

export type PostBotsByBotIdMcpByIdOauthDiscoverResponses = {
    /**
     * OK
     */
    200: McpDiscoveryResult;
};

export type PostBotsByBotIdMcpByIdOauthDiscoverResponse = PostBotsByBotIdMcpByIdOauthDiscoverResponses[keyof PostBotsByBotIdMcpByIdOauthDiscoverResponses];

export type PostBotsByBotIdMcpByIdOauthExchangeData = {
    /**
     * Authorization code and state
     */
    body: HandlersOauthExchangeRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}/oauth/exchange';
};

export type PostBotsByBotIdMcpByIdOauthExchangeErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpByIdOauthExchangeError = PostBotsByBotIdMcpByIdOauthExchangeErrors[keyof PostBotsByBotIdMcpByIdOauthExchangeErrors];

export type PostBotsByBotIdMcpByIdOauthExchangeResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: boolean;
    };
};

export type PostBotsByBotIdMcpByIdOauthExchangeResponse = PostBotsByBotIdMcpByIdOauthExchangeResponses[keyof PostBotsByBotIdMcpByIdOauthExchangeResponses];

export type GetBotsByBotIdMcpByIdOauthStatusData = {
    body?: never;
    path: {
        /**
         * MCP connection ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}/oauth/status';
};

export type GetBotsByBotIdMcpByIdOauthStatusErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetBotsByBotIdMcpByIdOauthStatusError = GetBotsByBotIdMcpByIdOauthStatusErrors[keyof GetBotsByBotIdMcpByIdOauthStatusErrors];

export type GetBotsByBotIdMcpByIdOauthStatusResponses = {
    /**
     * OK
     */
    200: McpOAuthStatus;
};

export type GetBotsByBotIdMcpByIdOauthStatusResponse = GetBotsByBotIdMcpByIdOauthStatusResponses[keyof GetBotsByBotIdMcpByIdOauthStatusResponses];

export type DeleteBotsByBotIdMcpByIdOauthTokenData = {
    body?: never;
    path: {
        /**
         * MCP connection ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}/oauth/token';
};

export type DeleteBotsByBotIdMcpByIdOauthTokenErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
};

export type DeleteBotsByBotIdMcpByIdOauthTokenError = DeleteBotsByBotIdMcpByIdOauthTokenErrors[keyof DeleteBotsByBotIdMcpByIdOauthTokenErrors];

export type DeleteBotsByBotIdMcpByIdOauthTokenResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type PostBotsByBotIdMcpByIdProbeData = {
    body?: never;
    path: {
        /**
         * MCP connection ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/mcp/{id}/probe';
};

export type PostBotsByBotIdMcpByIdProbeErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdMcpByIdProbeError = PostBotsByBotIdMcpByIdProbeErrors[keyof PostBotsByBotIdMcpByIdProbeErrors];

export type PostBotsByBotIdMcpByIdProbeResponses = {
    /**
     * OK
     */
    200: HandlersProbeResponse;
};

export type PostBotsByBotIdMcpByIdProbeResponse = PostBotsByBotIdMcpByIdProbeResponses[keyof PostBotsByBotIdMcpByIdProbeResponses];

export type DeleteBotsByBotIdMemoryData = {
    /**
     * Optional: specify memory_ids to delete; if omitted, deletes all
     */
    body?: HandlersMemoryDeletePayload;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory';
};

export type DeleteBotsByBotIdMemoryErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type DeleteBotsByBotIdMemoryError = DeleteBotsByBotIdMemoryErrors[keyof DeleteBotsByBotIdMemoryErrors];

export type DeleteBotsByBotIdMemoryResponses = {
    /**
     * OK
     */
    200: AdaptersDeleteResponse;
};

export type DeleteBotsByBotIdMemoryResponse = DeleteBotsByBotIdMemoryResponses[keyof DeleteBotsByBotIdMemoryResponses];

export type GetBotsByBotIdMemoryData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Skip optional stats in memory search response
         */
        no_stats?: boolean;
    };
    url: '/bots/{bot_id}/memory';
};

export type GetBotsByBotIdMemoryErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type GetBotsByBotIdMemoryError = GetBotsByBotIdMemoryErrors[keyof GetBotsByBotIdMemoryErrors];

export type GetBotsByBotIdMemoryResponses = {
    /**
     * OK
     */
    200: AdaptersSearchResponse;
};

export type GetBotsByBotIdMemoryResponse = GetBotsByBotIdMemoryResponses[keyof GetBotsByBotIdMemoryResponses];

export type PostBotsByBotIdMemoryData = {
    /**
     * Memory add payload
     */
    body: HandlersMemoryAddPayload;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory';
};

export type PostBotsByBotIdMemoryErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type PostBotsByBotIdMemoryError = PostBotsByBotIdMemoryErrors[keyof PostBotsByBotIdMemoryErrors];

export type PostBotsByBotIdMemoryResponses = {
    /**
     * OK
     */
    200: AdaptersSearchResponse;
};

export type PostBotsByBotIdMemoryResponse = PostBotsByBotIdMemoryResponses[keyof PostBotsByBotIdMemoryResponses];

export type PostBotsByBotIdMemoryCompactData = {
    /**
     * ratio (0,1] required; decay_days optional
     */
    body: HandlersMemoryCompactPayload;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory/compact';
};

export type PostBotsByBotIdMemoryCompactErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type PostBotsByBotIdMemoryCompactError = PostBotsByBotIdMemoryCompactErrors[keyof PostBotsByBotIdMemoryCompactErrors];

export type PostBotsByBotIdMemoryCompactResponses = {
    /**
     * OK
     */
    200: AdaptersCompactResult;
};

export type PostBotsByBotIdMemoryCompactResponse = PostBotsByBotIdMemoryCompactResponses[keyof PostBotsByBotIdMemoryCompactResponses];

export type PostBotsByBotIdMemoryRebuildData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory/rebuild';
};

export type PostBotsByBotIdMemoryRebuildErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Conflict
     */
    409: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type PostBotsByBotIdMemoryRebuildError = PostBotsByBotIdMemoryRebuildErrors[keyof PostBotsByBotIdMemoryRebuildErrors];

export type PostBotsByBotIdMemoryRebuildResponses = {
    /**
     * OK
     */
    200: AdaptersRebuildResult;
};

export type PostBotsByBotIdMemoryRebuildResponse = PostBotsByBotIdMemoryRebuildResponses[keyof PostBotsByBotIdMemoryRebuildResponses];

export type PostBotsByBotIdMemorySearchData = {
    /**
     * Memory search payload
     */
    body: HandlersMemorySearchPayload;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory/search';
};

export type PostBotsByBotIdMemorySearchErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type PostBotsByBotIdMemorySearchError = PostBotsByBotIdMemorySearchErrors[keyof PostBotsByBotIdMemorySearchErrors];

export type PostBotsByBotIdMemorySearchResponses = {
    /**
     * OK
     */
    200: AdaptersSearchResponse;
};

export type PostBotsByBotIdMemorySearchResponse = PostBotsByBotIdMemorySearchResponses[keyof PostBotsByBotIdMemorySearchResponses];

export type GetBotsByBotIdMemoryStatusData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory/status';
};

export type GetBotsByBotIdMemoryStatusErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Conflict
     */
    409: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type GetBotsByBotIdMemoryStatusError = GetBotsByBotIdMemoryStatusErrors[keyof GetBotsByBotIdMemoryStatusErrors];

export type GetBotsByBotIdMemoryStatusResponses = {
    /**
     * OK
     */
    200: AdaptersMemoryStatusResponse;
};

export type GetBotsByBotIdMemoryStatusResponse = GetBotsByBotIdMemoryStatusResponses[keyof GetBotsByBotIdMemoryStatusResponses];

export type GetBotsByBotIdMemoryUsageData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory/usage';
};

export type GetBotsByBotIdMemoryUsageErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type GetBotsByBotIdMemoryUsageError = GetBotsByBotIdMemoryUsageErrors[keyof GetBotsByBotIdMemoryUsageErrors];

export type GetBotsByBotIdMemoryUsageResponses = {
    /**
     * OK
     */
    200: AdaptersUsageResponse;
};

export type GetBotsByBotIdMemoryUsageResponse = GetBotsByBotIdMemoryUsageResponses[keyof GetBotsByBotIdMemoryUsageResponses];

export type DeleteBotsByBotIdMemoryByIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Memory ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/memory/{id}';
};

export type DeleteBotsByBotIdMemoryByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type DeleteBotsByBotIdMemoryByIdError = DeleteBotsByBotIdMemoryByIdErrors[keyof DeleteBotsByBotIdMemoryByIdErrors];

export type DeleteBotsByBotIdMemoryByIdResponses = {
    /**
     * OK
     */
    200: AdaptersDeleteResponse;
};

export type DeleteBotsByBotIdMemoryByIdResponse = DeleteBotsByBotIdMemoryByIdResponses[keyof DeleteBotsByBotIdMemoryByIdResponses];

export type DeleteBotsByBotIdMessagesData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/messages';
};

export type DeleteBotsByBotIdMessagesErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdMessagesError = DeleteBotsByBotIdMessagesErrors[keyof DeleteBotsByBotIdMessagesErrors];

export type DeleteBotsByBotIdMessagesResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdMessagesData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Limit
         */
        limit?: number;
        /**
         * Before
         */
        before?: string;
    };
    url: '/bots/{bot_id}/messages';
};

export type GetBotsByBotIdMessagesErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdMessagesError = GetBotsByBotIdMessagesErrors[keyof GetBotsByBotIdMessagesErrors];

export type GetBotsByBotIdMessagesResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: Array<MessageMessage>;
    };
};

export type GetBotsByBotIdMessagesResponse = GetBotsByBotIdMessagesResponses[keyof GetBotsByBotIdMessagesResponses];

export type GetBotsByBotIdScheduleData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/schedule';
};

export type GetBotsByBotIdScheduleErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdScheduleError = GetBotsByBotIdScheduleErrors[keyof GetBotsByBotIdScheduleErrors];

export type GetBotsByBotIdScheduleResponses = {
    /**
     * OK
     */
    200: ScheduleListResponse;
};

export type GetBotsByBotIdScheduleResponse = GetBotsByBotIdScheduleResponses[keyof GetBotsByBotIdScheduleResponses];

export type PostBotsByBotIdScheduleData = {
    /**
     * Schedule payload
     */
    body: ScheduleCreateRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/schedule';
};

export type PostBotsByBotIdScheduleErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdScheduleError = PostBotsByBotIdScheduleErrors[keyof PostBotsByBotIdScheduleErrors];

export type PostBotsByBotIdScheduleResponses = {
    /**
     * Created
     */
    201: ScheduleSchedule;
};

export type PostBotsByBotIdScheduleResponse = PostBotsByBotIdScheduleResponses[keyof PostBotsByBotIdScheduleResponses];

export type DeleteBotsByBotIdScheduleLogsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/schedule/logs';
};

export type DeleteBotsByBotIdScheduleLogsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdScheduleLogsError = DeleteBotsByBotIdScheduleLogsErrors[keyof DeleteBotsByBotIdScheduleLogsErrors];

export type DeleteBotsByBotIdScheduleLogsResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdScheduleLogsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Before timestamp (RFC3339)
         */
        before?: string;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/bots/{bot_id}/schedule/logs';
};

export type GetBotsByBotIdScheduleLogsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdScheduleLogsError = GetBotsByBotIdScheduleLogsErrors[keyof GetBotsByBotIdScheduleLogsErrors];

export type GetBotsByBotIdScheduleLogsResponses = {
    /**
     * OK
     */
    200: ScheduleListLogsResponse;
};

export type GetBotsByBotIdScheduleLogsResponse = GetBotsByBotIdScheduleLogsResponses[keyof GetBotsByBotIdScheduleLogsResponses];

export type DeleteBotsByBotIdScheduleByIdData = {
    body?: never;
    path: {
        /**
         * Schedule ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/schedule/{id}';
};

export type DeleteBotsByBotIdScheduleByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdScheduleByIdError = DeleteBotsByBotIdScheduleByIdErrors[keyof DeleteBotsByBotIdScheduleByIdErrors];

export type DeleteBotsByBotIdScheduleByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdScheduleByIdData = {
    body?: never;
    path: {
        /**
         * Schedule ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/schedule/{id}';
};

export type GetBotsByBotIdScheduleByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdScheduleByIdError = GetBotsByBotIdScheduleByIdErrors[keyof GetBotsByBotIdScheduleByIdErrors];

export type GetBotsByBotIdScheduleByIdResponses = {
    /**
     * OK
     */
    200: ScheduleSchedule;
};

export type GetBotsByBotIdScheduleByIdResponse = GetBotsByBotIdScheduleByIdResponses[keyof GetBotsByBotIdScheduleByIdResponses];

export type PutBotsByBotIdScheduleByIdData = {
    /**
     * Schedule payload
     */
    body: ScheduleUpdateRequest;
    path: {
        /**
         * Schedule ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/schedule/{id}';
};

export type PutBotsByBotIdScheduleByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByBotIdScheduleByIdError = PutBotsByBotIdScheduleByIdErrors[keyof PutBotsByBotIdScheduleByIdErrors];

export type PutBotsByBotIdScheduleByIdResponses = {
    /**
     * OK
     */
    200: ScheduleSchedule;
};

export type PutBotsByBotIdScheduleByIdResponse = PutBotsByBotIdScheduleByIdResponses[keyof PutBotsByBotIdScheduleByIdResponses];

export type GetBotsByBotIdScheduleByIdLogsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Schedule ID
         */
        id: string;
    };
    query?: {
        /**
         * Before timestamp (RFC3339)
         */
        before?: string;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/bots/{bot_id}/schedule/{id}/logs';
};

export type GetBotsByBotIdScheduleByIdLogsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdScheduleByIdLogsError = GetBotsByBotIdScheduleByIdLogsErrors[keyof GetBotsByBotIdScheduleByIdLogsErrors];

export type GetBotsByBotIdScheduleByIdLogsResponses = {
    /**
     * OK
     */
    200: ScheduleListLogsResponse;
};

export type GetBotsByBotIdScheduleByIdLogsResponse = GetBotsByBotIdScheduleByIdLogsResponses[keyof GetBotsByBotIdScheduleByIdLogsResponses];

export type GetBotsByBotIdSessionsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/sessions';
};

export type GetBotsByBotIdSessionsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
};

export type GetBotsByBotIdSessionsError = GetBotsByBotIdSessionsErrors[keyof GetBotsByBotIdSessionsErrors];

export type GetBotsByBotIdSessionsResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: Array<SessionSession>;
    };
};

export type GetBotsByBotIdSessionsResponse = GetBotsByBotIdSessionsResponses[keyof GetBotsByBotIdSessionsResponses];

export type PostBotsByBotIdSessionsData = {
    /**
     * Session data
     */
    body: HandlersCreateSessionRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/sessions';
};

export type PostBotsByBotIdSessionsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
};

export type PostBotsByBotIdSessionsError = PostBotsByBotIdSessionsErrors[keyof PostBotsByBotIdSessionsErrors];

export type PostBotsByBotIdSessionsResponses = {
    /**
     * Created
     */
    201: SessionSession;
};

export type PostBotsByBotIdSessionsResponse = PostBotsByBotIdSessionsResponses[keyof PostBotsByBotIdSessionsResponses];

export type DeleteBotsByBotIdSessionsBySessionIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/sessions/{session_id}';
};

export type DeleteBotsByBotIdSessionsBySessionIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
};

export type DeleteBotsByBotIdSessionsBySessionIdError = DeleteBotsByBotIdSessionsBySessionIdErrors[keyof DeleteBotsByBotIdSessionsBySessionIdErrors];

export type DeleteBotsByBotIdSessionsBySessionIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdSessionsBySessionIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/sessions/{session_id}';
};

export type GetBotsByBotIdSessionsBySessionIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetBotsByBotIdSessionsBySessionIdError = GetBotsByBotIdSessionsBySessionIdErrors[keyof GetBotsByBotIdSessionsBySessionIdErrors];

export type GetBotsByBotIdSessionsBySessionIdResponses = {
    /**
     * OK
     */
    200: SessionSession;
};

export type GetBotsByBotIdSessionsBySessionIdResponse = GetBotsByBotIdSessionsBySessionIdResponses[keyof GetBotsByBotIdSessionsBySessionIdResponses];

export type PatchBotsByBotIdSessionsBySessionIdData = {
    /**
     * Fields to update
     */
    body: HandlersUpdateSessionRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/sessions/{session_id}';
};

export type PatchBotsByBotIdSessionsBySessionIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type PatchBotsByBotIdSessionsBySessionIdError = PatchBotsByBotIdSessionsBySessionIdErrors[keyof PatchBotsByBotIdSessionsBySessionIdErrors];

export type PatchBotsByBotIdSessionsBySessionIdResponses = {
    /**
     * OK
     */
    200: SessionSession;
};

export type PatchBotsByBotIdSessionsBySessionIdResponse = PatchBotsByBotIdSessionsBySessionIdResponses[keyof PatchBotsByBotIdSessionsBySessionIdResponses];

export type DeleteBotsByBotIdSettingsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/settings';
};

export type DeleteBotsByBotIdSettingsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdSettingsError = DeleteBotsByBotIdSettingsErrors[keyof DeleteBotsByBotIdSettingsErrors];

export type DeleteBotsByBotIdSettingsResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByBotIdSettingsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/settings';
};

export type GetBotsByBotIdSettingsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdSettingsError = GetBotsByBotIdSettingsErrors[keyof GetBotsByBotIdSettingsErrors];

export type GetBotsByBotIdSettingsResponses = {
    /**
     * OK
     */
    200: SettingsSettings;
};

export type GetBotsByBotIdSettingsResponse = GetBotsByBotIdSettingsResponses[keyof GetBotsByBotIdSettingsResponses];

export type PostBotsByBotIdSettingsData = {
    /**
     * Settings payload
     */
    body: SettingsUpsertRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/settings';
};

export type PostBotsByBotIdSettingsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdSettingsError = PostBotsByBotIdSettingsErrors[keyof PostBotsByBotIdSettingsErrors];

export type PostBotsByBotIdSettingsResponses = {
    /**
     * OK
     */
    200: SettingsSettings;
};

export type PostBotsByBotIdSettingsResponse = PostBotsByBotIdSettingsResponses[keyof PostBotsByBotIdSettingsResponses];

export type PutBotsByBotIdSettingsData = {
    /**
     * Settings payload
     */
    body: SettingsUpsertRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/settings';
};

export type PutBotsByBotIdSettingsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByBotIdSettingsError = PutBotsByBotIdSettingsErrors[keyof PutBotsByBotIdSettingsErrors];

export type PutBotsByBotIdSettingsResponses = {
    /**
     * OK
     */
    200: SettingsSettings;
};

export type PutBotsByBotIdSettingsResponse = PutBotsByBotIdSettingsResponses[keyof PutBotsByBotIdSettingsResponses];

export type GetBotsByBotIdTokenUsageData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query: {
        /**
         * Start date (YYYY-MM-DD)
         */
        from: string;
        /**
         * End date exclusive (YYYY-MM-DD)
         */
        to: string;
        /**
         * Optional model UUID to filter by
         */
        model_id?: string;
    };
    url: '/bots/{bot_id}/token-usage';
};

export type GetBotsByBotIdTokenUsageErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdTokenUsageError = GetBotsByBotIdTokenUsageErrors[keyof GetBotsByBotIdTokenUsageErrors];

export type GetBotsByBotIdTokenUsageResponses = {
    /**
     * OK
     */
    200: HandlersTokenUsageResponse;
};

export type GetBotsByBotIdTokenUsageResponse = GetBotsByBotIdTokenUsageResponses[keyof GetBotsByBotIdTokenUsageResponses];

export type PostBotsByBotIdToolsData = {
    /**
     * JSON-RPC request
     */
    body: {
        [key: string]: unknown;
    };
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/tools';
};

export type PostBotsByBotIdToolsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdToolsError = PostBotsByBotIdToolsErrors[keyof PostBotsByBotIdToolsErrors];

export type PostBotsByBotIdToolsResponses = {
    /**
     * JSON-RPC response: {jsonrpc,id,result|error}
     */
    200: {
        [key: string]: unknown;
    };
};

export type PostBotsByBotIdToolsResponse = PostBotsByBotIdToolsResponses[keyof PostBotsByBotIdToolsResponses];

export type PostBotsByBotIdTtsSynthesizeData = {
    /**
     * Text to synthesize
     */
    body: HandlersSynthesizeRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/tts/synthesize';
};

export type PostBotsByBotIdTtsSynthesizeErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdTtsSynthesizeError = PostBotsByBotIdTtsSynthesizeErrors[keyof PostBotsByBotIdTtsSynthesizeErrors];

export type PostBotsByBotIdTtsSynthesizeResponses = {
    /**
     * OK
     */
    200: HandlersSynthesizeResponse;
};

export type PostBotsByBotIdTtsSynthesizeResponse = PostBotsByBotIdTtsSynthesizeResponses[keyof PostBotsByBotIdTtsSynthesizeResponses];

export type PostBotsByBotIdWebMessagesData = {
    /**
     * Message payload
     */
    body: HandlersLocalChannelMessageRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/web/messages';
};

export type PostBotsByBotIdWebMessagesErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByBotIdWebMessagesError = PostBotsByBotIdWebMessagesErrors[keyof PostBotsByBotIdWebMessagesErrors];

export type PostBotsByBotIdWebMessagesResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: string;
    };
};

export type PostBotsByBotIdWebMessagesResponse = PostBotsByBotIdWebMessagesResponses[keyof PostBotsByBotIdWebMessagesResponses];

export type GetBotsByBotIdWebStreamData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/web/stream';
};

export type GetBotsByBotIdWebStreamErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdWebStreamError = GetBotsByBotIdWebStreamErrors[keyof GetBotsByBotIdWebStreamErrors];

export type GetBotsByBotIdWebStreamResponses = {
    /**
     * SSE stream
     */
    200: string;
};

export type GetBotsByBotIdWebStreamResponse = GetBotsByBotIdWebStreamResponses[keyof GetBotsByBotIdWebStreamResponses];

export type GetBotsByBotIdWebWsData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/web/ws';
};

export type GetBotsByBotIdWebWsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdWebWsError = GetBotsByBotIdWebWsErrors[keyof GetBotsByBotIdWebWsErrors];

export type GetBotsByBotIdWhitelistData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/whitelist';
};

export type GetBotsByBotIdWhitelistErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByBotIdWhitelistError = GetBotsByBotIdWhitelistErrors[keyof GetBotsByBotIdWhitelistErrors];

export type GetBotsByBotIdWhitelistResponses = {
    /**
     * OK
     */
    200: AclListRulesResponse;
};

export type GetBotsByBotIdWhitelistResponse = GetBotsByBotIdWhitelistResponses[keyof GetBotsByBotIdWhitelistResponses];

export type PutBotsByBotIdWhitelistData = {
    /**
     * Whitelist payload
     */
    body: AclUpsertRuleRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/whitelist';
};

export type PutBotsByBotIdWhitelistErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByBotIdWhitelistError = PutBotsByBotIdWhitelistErrors[keyof PutBotsByBotIdWhitelistErrors];

export type PutBotsByBotIdWhitelistResponses = {
    /**
     * OK
     */
    200: AclRule;
};

export type PutBotsByBotIdWhitelistResponse = PutBotsByBotIdWhitelistResponses[keyof PutBotsByBotIdWhitelistResponses];

export type DeleteBotsByBotIdWhitelistByRuleIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Rule ID
         */
        rule_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/whitelist/{rule_id}';
};

export type DeleteBotsByBotIdWhitelistByRuleIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByBotIdWhitelistByRuleIdError = DeleteBotsByBotIdWhitelistByRuleIdErrors[keyof DeleteBotsByBotIdWhitelistByRuleIdErrors];

export type DeleteBotsByBotIdWhitelistByRuleIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type DeleteBotsByIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{id}';
};

export type DeleteBotsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByIdError = DeleteBotsByIdErrors[keyof DeleteBotsByIdErrors];

export type DeleteBotsByIdResponses = {
    /**
     * Accepted
     */
    202: {
        [key: string]: string;
    };
};

export type DeleteBotsByIdResponse = DeleteBotsByIdResponses[keyof DeleteBotsByIdResponses];

export type GetBotsByIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{id}';
};

export type GetBotsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByIdError = GetBotsByIdErrors[keyof GetBotsByIdErrors];

export type GetBotsByIdResponses = {
    /**
     * OK
     */
    200: BotsBot;
};

export type GetBotsByIdResponse = GetBotsByIdResponses[keyof GetBotsByIdResponses];

export type PutBotsByIdData = {
    /**
     * Bot update payload
     */
    body: BotsUpdateBotRequest;
    path: {
        /**
         * Bot ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{id}';
};

export type PutBotsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByIdError = PutBotsByIdErrors[keyof PutBotsByIdErrors];

export type PutBotsByIdResponses = {
    /**
     * OK
     */
    200: BotsBot;
};

export type PutBotsByIdResponse = PutBotsByIdResponses[keyof PutBotsByIdResponses];

export type DeleteBotsByIdChannelByPlatformData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        id: string;
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/bots/{id}/channel/{platform}';
};

export type DeleteBotsByIdChannelByPlatformErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBotsByIdChannelByPlatformError = DeleteBotsByIdChannelByPlatformErrors[keyof DeleteBotsByIdChannelByPlatformErrors];

export type DeleteBotsByIdChannelByPlatformResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBotsByIdChannelByPlatformData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        id: string;
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/bots/{id}/channel/{platform}';
};

export type GetBotsByIdChannelByPlatformErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByIdChannelByPlatformError = GetBotsByIdChannelByPlatformErrors[keyof GetBotsByIdChannelByPlatformErrors];

export type GetBotsByIdChannelByPlatformResponses = {
    /**
     * OK
     */
    200: ChannelChannelConfig;
};

export type GetBotsByIdChannelByPlatformResponse = GetBotsByIdChannelByPlatformResponses[keyof GetBotsByIdChannelByPlatformResponses];

export type PutBotsByIdChannelByPlatformData = {
    /**
     * Channel config payload
     */
    body: ChannelUpsertConfigRequest;
    path: {
        /**
         * Bot ID
         */
        id: string;
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/bots/{id}/channel/{platform}';
};

export type PutBotsByIdChannelByPlatformErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByIdChannelByPlatformError = PutBotsByIdChannelByPlatformErrors[keyof PutBotsByIdChannelByPlatformErrors];

export type PutBotsByIdChannelByPlatformResponses = {
    /**
     * OK
     */
    200: ChannelChannelConfig;
};

export type PutBotsByIdChannelByPlatformResponse = PutBotsByIdChannelByPlatformResponses[keyof PutBotsByIdChannelByPlatformResponses];

export type PostBotsByIdChannelByPlatformSendData = {
    /**
     * Send payload
     */
    body: ChannelSendRequest;
    path: {
        /**
         * Bot ID
         */
        id: string;
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/bots/{id}/channel/{platform}/send';
};

export type PostBotsByIdChannelByPlatformSendErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByIdChannelByPlatformSendError = PostBotsByIdChannelByPlatformSendErrors[keyof PostBotsByIdChannelByPlatformSendErrors];

export type PostBotsByIdChannelByPlatformSendResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: string;
    };
};

export type PostBotsByIdChannelByPlatformSendResponse = PostBotsByIdChannelByPlatformSendResponses[keyof PostBotsByIdChannelByPlatformSendResponses];

export type PostBotsByIdChannelByPlatformSendChatData = {
    /**
     * Send payload
     */
    body: ChannelSendRequest;
    path: {
        /**
         * Bot ID
         */
        id: string;
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/bots/{id}/channel/{platform}/send_chat';
};

export type PostBotsByIdChannelByPlatformSendChatErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Unauthorized
     */
    401: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBotsByIdChannelByPlatformSendChatError = PostBotsByIdChannelByPlatformSendChatErrors[keyof PostBotsByIdChannelByPlatformSendChatErrors];

export type PostBotsByIdChannelByPlatformSendChatResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: string;
    };
};

export type PostBotsByIdChannelByPlatformSendChatResponse = PostBotsByIdChannelByPlatformSendChatResponses[keyof PostBotsByIdChannelByPlatformSendChatResponses];

export type PatchBotsByIdChannelByPlatformStatusData = {
    /**
     * Channel status payload
     */
    body: ChannelUpdateChannelStatusRequest;
    path: {
        /**
         * Bot ID
         */
        id: string;
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/bots/{id}/channel/{platform}/status';
};

export type PatchBotsByIdChannelByPlatformStatusErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PatchBotsByIdChannelByPlatformStatusError = PatchBotsByIdChannelByPlatformStatusErrors[keyof PatchBotsByIdChannelByPlatformStatusErrors];

export type PatchBotsByIdChannelByPlatformStatusResponses = {
    /**
     * OK
     */
    200: ChannelChannelConfig;
};

export type PatchBotsByIdChannelByPlatformStatusResponse = PatchBotsByIdChannelByPlatformStatusResponses[keyof PatchBotsByIdChannelByPlatformStatusResponses];

export type GetBotsByIdChecksData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{id}/checks';
};

export type GetBotsByIdChecksErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBotsByIdChecksError = GetBotsByIdChecksErrors[keyof GetBotsByIdChecksErrors];

export type GetBotsByIdChecksResponses = {
    /**
     * OK
     */
    200: BotsListChecksResponse;
};

export type GetBotsByIdChecksResponse = GetBotsByIdChecksResponses[keyof GetBotsByIdChecksResponses];

export type PutBotsByIdOwnerData = {
    /**
     * Transfer payload
     */
    body: BotsTransferBotRequest;
    path: {
        /**
         * Bot ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{id}/owner';
};

export type PutBotsByIdOwnerErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBotsByIdOwnerError = PutBotsByIdOwnerErrors[keyof PutBotsByIdOwnerErrors];

export type PutBotsByIdOwnerResponses = {
    /**
     * OK
     */
    200: BotsBot;
};

export type PutBotsByIdOwnerResponse = PutBotsByIdOwnerResponses[keyof PutBotsByIdOwnerResponses];

export type GetBrowserContextsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/browser-contexts';
};

export type GetBrowserContextsErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetBrowserContextsError = GetBrowserContextsErrors[keyof GetBrowserContextsErrors];

export type GetBrowserContextsResponses = {
    /**
     * OK
     */
    200: Array<BrowsercontextsBrowserContext>;
};

export type GetBrowserContextsResponse = GetBrowserContextsResponses[keyof GetBrowserContextsResponses];

export type PostBrowserContextsData = {
    /**
     * Browser context configuration
     */
    body: BrowsercontextsCreateRequest;
    path?: never;
    query?: never;
    url: '/browser-contexts';
};

export type PostBrowserContextsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostBrowserContextsError = PostBrowserContextsErrors[keyof PostBrowserContextsErrors];

export type PostBrowserContextsResponses = {
    /**
     * Created
     */
    201: BrowsercontextsBrowserContext;
};

export type PostBrowserContextsResponse = PostBrowserContextsResponses[keyof PostBrowserContextsResponses];

export type GetBrowserContextsCoresData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/browser-contexts/cores';
};

export type GetBrowserContextsCoresErrors = {
    /**
     * Bad Gateway
     */
    502: HandlersErrorResponse;
};

export type GetBrowserContextsCoresError = GetBrowserContextsCoresErrors[keyof GetBrowserContextsCoresErrors];

export type GetBrowserContextsCoresResponses = {
    /**
     * OK
     */
    200: HandlersBrowserCoresResponse;
};

export type GetBrowserContextsCoresResponse = GetBrowserContextsCoresResponses[keyof GetBrowserContextsCoresResponses];

export type DeleteBrowserContextsByIdData = {
    body?: never;
    path: {
        /**
         * Browser Context ID
         */
        id: string;
    };
    query?: never;
    url: '/browser-contexts/{id}';
};

export type DeleteBrowserContextsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteBrowserContextsByIdError = DeleteBrowserContextsByIdErrors[keyof DeleteBrowserContextsByIdErrors];

export type DeleteBrowserContextsByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetBrowserContextsByIdData = {
    body?: never;
    path: {
        /**
         * Browser Context ID
         */
        id: string;
    };
    query?: never;
    url: '/browser-contexts/{id}';
};

export type GetBrowserContextsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetBrowserContextsByIdError = GetBrowserContextsByIdErrors[keyof GetBrowserContextsByIdErrors];

export type GetBrowserContextsByIdResponses = {
    /**
     * OK
     */
    200: BrowsercontextsBrowserContext;
};

export type GetBrowserContextsByIdResponse = GetBrowserContextsByIdResponses[keyof GetBrowserContextsByIdResponses];

export type PutBrowserContextsByIdData = {
    /**
     * Updated configuration
     */
    body: BrowsercontextsUpdateRequest;
    path: {
        /**
         * Browser Context ID
         */
        id: string;
    };
    query?: never;
    url: '/browser-contexts/{id}';
};

export type PutBrowserContextsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutBrowserContextsByIdError = PutBrowserContextsByIdErrors[keyof PutBrowserContextsByIdErrors];

export type PutBrowserContextsByIdResponses = {
    /**
     * OK
     */
    200: BrowsercontextsBrowserContext;
};

export type PutBrowserContextsByIdResponse = PutBrowserContextsByIdResponses[keyof PutBrowserContextsByIdResponses];

export type GetChannelsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/channels';
};

export type GetChannelsErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetChannelsError = GetChannelsErrors[keyof GetChannelsErrors];

export type GetChannelsResponses = {
    /**
     * OK
     */
    200: Array<HandlersChannelMeta>;
};

export type GetChannelsResponse = GetChannelsResponses[keyof GetChannelsResponses];

export type GetChannelsByPlatformData = {
    body?: never;
    path: {
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/channels/{platform}';
};

export type GetChannelsByPlatformErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetChannelsByPlatformError = GetChannelsByPlatformErrors[keyof GetChannelsByPlatformErrors];

export type GetChannelsByPlatformResponses = {
    /**
     * OK
     */
    200: HandlersChannelMeta;
};

export type GetChannelsByPlatformResponse = GetChannelsByPlatformResponses[keyof GetChannelsByPlatformResponses];

export type GetEmailProvidersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Provider type filter
         */
        provider?: string;
    };
    url: '/email-providers';
};

export type GetEmailProvidersErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetEmailProvidersError = GetEmailProvidersErrors[keyof GetEmailProvidersErrors];

export type GetEmailProvidersResponses = {
    /**
     * OK
     */
    200: Array<EmailProviderResponse>;
};

export type GetEmailProvidersResponse = GetEmailProvidersResponses[keyof GetEmailProvidersResponses];

export type PostEmailProvidersData = {
    /**
     * Email provider configuration
     */
    body: EmailCreateProviderRequest;
    path?: never;
    query?: never;
    url: '/email-providers';
};

export type PostEmailProvidersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostEmailProvidersError = PostEmailProvidersErrors[keyof PostEmailProvidersErrors];

export type PostEmailProvidersResponses = {
    /**
     * Created
     */
    201: EmailProviderResponse;
};

export type PostEmailProvidersResponse = PostEmailProvidersResponses[keyof PostEmailProvidersResponses];

export type GetEmailProvidersMetaData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/email-providers/meta';
};

export type GetEmailProvidersMetaResponses = {
    /**
     * OK
     */
    200: Array<EmailProviderMeta>;
};

export type GetEmailProvidersMetaResponse = GetEmailProvidersMetaResponses[keyof GetEmailProvidersMetaResponses];

export type DeleteEmailProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/email-providers/{id}';
};

export type DeleteEmailProvidersByIdErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteEmailProvidersByIdError = DeleteEmailProvidersByIdErrors[keyof DeleteEmailProvidersByIdErrors];

export type DeleteEmailProvidersByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetEmailProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/email-providers/{id}';
};

export type GetEmailProvidersByIdErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetEmailProvidersByIdError = GetEmailProvidersByIdErrors[keyof GetEmailProvidersByIdErrors];

export type GetEmailProvidersByIdResponses = {
    /**
     * OK
     */
    200: EmailProviderResponse;
};

export type GetEmailProvidersByIdResponse = GetEmailProvidersByIdResponses[keyof GetEmailProvidersByIdResponses];

export type PutEmailProvidersByIdData = {
    /**
     * Updated configuration
     */
    body: EmailUpdateProviderRequest;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/email-providers/{id}';
};

export type PutEmailProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutEmailProvidersByIdError = PutEmailProvidersByIdErrors[keyof PutEmailProvidersByIdErrors];

export type PutEmailProvidersByIdResponses = {
    /**
     * OK
     */
    200: EmailProviderResponse;
};

export type PutEmailProvidersByIdResponse = PutEmailProvidersByIdResponses[keyof PutEmailProvidersByIdResponses];

export type GetEmailProvidersByIdOauthAuthorizeData = {
    body?: never;
    path: {
        /**
         * Email provider ID
         */
        id: string;
    };
    query?: never;
    url: '/email-providers/{id}/oauth/authorize';
};

export type GetEmailProvidersByIdOauthAuthorizeErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetEmailProvidersByIdOauthAuthorizeError = GetEmailProvidersByIdOauthAuthorizeErrors[keyof GetEmailProvidersByIdOauthAuthorizeErrors];

export type GetEmailProvidersByIdOauthAuthorizeResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: string;
    };
};

export type GetEmailProvidersByIdOauthAuthorizeResponse = GetEmailProvidersByIdOauthAuthorizeResponses[keyof GetEmailProvidersByIdOauthAuthorizeResponses];

export type GetEmailProvidersByIdOauthStatusData = {
    body?: never;
    path: {
        /**
         * Email provider ID
         */
        id: string;
    };
    query?: never;
    url: '/email-providers/{id}/oauth/status';
};

export type GetEmailProvidersByIdOauthStatusErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetEmailProvidersByIdOauthStatusError = GetEmailProvidersByIdOauthStatusErrors[keyof GetEmailProvidersByIdOauthStatusErrors];

export type GetEmailProvidersByIdOauthStatusResponses = {
    /**
     * OK
     */
    200: HandlersEmailOAuthStatusResponse;
};

export type GetEmailProvidersByIdOauthStatusResponse = GetEmailProvidersByIdOauthStatusResponses[keyof GetEmailProvidersByIdOauthStatusResponses];

export type DeleteEmailProvidersByIdOauthTokenData = {
    body?: never;
    path: {
        /**
         * Email provider ID
         */
        id: string;
    };
    query?: never;
    url: '/email-providers/{id}/oauth/token';
};

export type DeleteEmailProvidersByIdOauthTokenErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type DeleteEmailProvidersByIdOauthTokenError = DeleteEmailProvidersByIdOauthTokenErrors[keyof DeleteEmailProvidersByIdOauthTokenErrors];

export type DeleteEmailProvidersByIdOauthTokenResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type PostEmailMailgunWebhookByConfigIdData = {
    body?: never;
    path: {
        /**
         * Email provider config ID
         */
        config_id: string;
    };
    query?: never;
    url: '/email/mailgun/webhook/{config_id}';
};

export type PostEmailMailgunWebhookByConfigIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostEmailMailgunWebhookByConfigIdError = PostEmailMailgunWebhookByConfigIdErrors[keyof PostEmailMailgunWebhookByConfigIdErrors];

export type PostEmailMailgunWebhookByConfigIdResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: string;
    };
};

export type PostEmailMailgunWebhookByConfigIdResponse = PostEmailMailgunWebhookByConfigIdResponses[keyof PostEmailMailgunWebhookByConfigIdResponses];

export type GetEmailOauthCallbackData = {
    body?: never;
    path?: never;
    query: {
        /**
         * Authorization code
         */
        code: string;
        /**
         * State parameter
         */
        state: string;
    };
    url: '/email/oauth/callback';
};

export type GetEmailOauthCallbackErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetEmailOauthCallbackError = GetEmailOauthCallbackErrors[keyof GetEmailOauthCallbackErrors];

export type GetEmailOauthCallbackResponses = {
    /**
     * OK
     */
    200: {
        [key: string]: string;
    };
};

export type GetEmailOauthCallbackResponse = GetEmailOauthCallbackResponses[keyof GetEmailOauthCallbackResponses];

export type GetMemoryProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/memory-providers';
};

export type GetMemoryProvidersErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetMemoryProvidersError = GetMemoryProvidersErrors[keyof GetMemoryProvidersErrors];

export type GetMemoryProvidersResponses = {
    /**
     * OK
     */
    200: Array<AdaptersProviderGetResponse>;
};

export type GetMemoryProvidersResponse = GetMemoryProvidersResponses[keyof GetMemoryProvidersResponses];

export type PostMemoryProvidersData = {
    /**
     * Memory provider configuration
     */
    body: AdaptersProviderCreateRequest;
    path?: never;
    query?: never;
    url: '/memory-providers';
};

export type PostMemoryProvidersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostMemoryProvidersError = PostMemoryProvidersErrors[keyof PostMemoryProvidersErrors];

export type PostMemoryProvidersResponses = {
    /**
     * Created
     */
    201: AdaptersProviderGetResponse;
};

export type PostMemoryProvidersResponse = PostMemoryProvidersResponses[keyof PostMemoryProvidersResponses];

export type GetMemoryProvidersMetaData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/memory-providers/meta';
};

export type GetMemoryProvidersMetaResponses = {
    /**
     * OK
     */
    200: Array<AdaptersProviderMeta>;
};

export type GetMemoryProvidersMetaResponse = GetMemoryProvidersMetaResponses[keyof GetMemoryProvidersMetaResponses];

export type DeleteMemoryProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/memory-providers/{id}';
};

export type DeleteMemoryProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteMemoryProvidersByIdError = DeleteMemoryProvidersByIdErrors[keyof DeleteMemoryProvidersByIdErrors];

export type DeleteMemoryProvidersByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetMemoryProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/memory-providers/{id}';
};

export type GetMemoryProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetMemoryProvidersByIdError = GetMemoryProvidersByIdErrors[keyof GetMemoryProvidersByIdErrors];

export type GetMemoryProvidersByIdResponses = {
    /**
     * OK
     */
    200: AdaptersProviderGetResponse;
};

export type GetMemoryProvidersByIdResponse = GetMemoryProvidersByIdResponses[keyof GetMemoryProvidersByIdResponses];

export type PutMemoryProvidersByIdData = {
    /**
     * Updated configuration
     */
    body: AdaptersProviderUpdateRequest;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/memory-providers/{id}';
};

export type PutMemoryProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutMemoryProvidersByIdError = PutMemoryProvidersByIdErrors[keyof PutMemoryProvidersByIdErrors];

export type PutMemoryProvidersByIdResponses = {
    /**
     * OK
     */
    200: AdaptersProviderGetResponse;
};

export type PutMemoryProvidersByIdResponse = PutMemoryProvidersByIdResponses[keyof PutMemoryProvidersByIdResponses];

export type GetMemoryProvidersByIdStatusData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/memory-providers/{id}/status';
};

export type GetMemoryProvidersByIdStatusErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetMemoryProvidersByIdStatusError = GetMemoryProvidersByIdStatusErrors[keyof GetMemoryProvidersByIdStatusErrors];

export type GetMemoryProvidersByIdStatusResponses = {
    /**
     * OK
     */
    200: AdaptersProviderStatusResponse;
};

export type GetMemoryProvidersByIdStatusResponse = GetMemoryProvidersByIdStatusResponses[keyof GetMemoryProvidersByIdStatusResponses];

export type GetModelsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Model type (chat, embedding)
         */
        type?: string;
        /**
         * Provider client type (openai-responses, openai-completions, anthropic-messages, google-generative-ai)
         */
        client_type?: string;
    };
    url: '/models';
};

export type GetModelsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetModelsError = GetModelsErrors[keyof GetModelsErrors];

export type GetModelsResponses = {
    /**
     * OK
     */
    200: Array<ModelsGetResponse>;
};

export type GetModelsResponse = GetModelsResponses[keyof GetModelsResponses];

export type PostModelsData = {
    /**
     * Model configuration
     */
    body: ModelsAddRequest;
    path?: never;
    query?: never;
    url: '/models';
};

export type PostModelsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostModelsError = PostModelsErrors[keyof PostModelsErrors];

export type PostModelsResponses = {
    /**
     * Created
     */
    201: ModelsAddResponse;
};

export type PostModelsResponse = PostModelsResponses[keyof PostModelsResponses];

export type GetModelsCountData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Model type (chat, embedding)
         */
        type?: string;
    };
    url: '/models/count';
};

export type GetModelsCountErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetModelsCountError = GetModelsCountErrors[keyof GetModelsCountErrors];

export type GetModelsCountResponses = {
    /**
     * OK
     */
    200: ModelsCountResponse;
};

export type GetModelsCountResponse = GetModelsCountResponses[keyof GetModelsCountResponses];

export type DeleteModelsModelByModelIdData = {
    body?: never;
    path: {
        /**
         * Model ID (e.g., gpt-4)
         */
        modelId: string;
    };
    query?: never;
    url: '/models/model/{modelId}';
};

export type DeleteModelsModelByModelIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteModelsModelByModelIdError = DeleteModelsModelByModelIdErrors[keyof DeleteModelsModelByModelIdErrors];

export type DeleteModelsModelByModelIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetModelsModelByModelIdData = {
    body?: never;
    path: {
        /**
         * Model ID (e.g., gpt-4)
         */
        modelId: string;
    };
    query?: never;
    url: '/models/model/{modelId}';
};

export type GetModelsModelByModelIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetModelsModelByModelIdError = GetModelsModelByModelIdErrors[keyof GetModelsModelByModelIdErrors];

export type GetModelsModelByModelIdResponses = {
    /**
     * OK
     */
    200: ModelsGetResponse;
};

export type GetModelsModelByModelIdResponse = GetModelsModelByModelIdResponses[keyof GetModelsModelByModelIdResponses];

export type PutModelsModelByModelIdData = {
    /**
     * Updated model configuration
     */
    body: ModelsUpdateRequest;
    path: {
        /**
         * Model ID (e.g., gpt-4)
         */
        modelId: string;
    };
    query?: never;
    url: '/models/model/{modelId}';
};

export type PutModelsModelByModelIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutModelsModelByModelIdError = PutModelsModelByModelIdErrors[keyof PutModelsModelByModelIdErrors];

export type PutModelsModelByModelIdResponses = {
    /**
     * OK
     */
    200: ModelsGetResponse;
};

export type PutModelsModelByModelIdResponse = PutModelsModelByModelIdResponses[keyof PutModelsModelByModelIdResponses];

export type DeleteModelsByIdData = {
    body?: never;
    path: {
        /**
         * Model internal ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/models/{id}';
};

export type DeleteModelsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteModelsByIdError = DeleteModelsByIdErrors[keyof DeleteModelsByIdErrors];

export type DeleteModelsByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetModelsByIdData = {
    body?: never;
    path: {
        /**
         * Model internal ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/models/{id}';
};

export type GetModelsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetModelsByIdError = GetModelsByIdErrors[keyof GetModelsByIdErrors];

export type GetModelsByIdResponses = {
    /**
     * OK
     */
    200: ModelsGetResponse;
};

export type GetModelsByIdResponse = GetModelsByIdResponses[keyof GetModelsByIdResponses];

export type PutModelsByIdData = {
    /**
     * Updated model configuration
     */
    body: ModelsUpdateRequest;
    path: {
        /**
         * Model internal ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/models/{id}';
};

export type PutModelsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutModelsByIdError = PutModelsByIdErrors[keyof PutModelsByIdErrors];

export type PutModelsByIdResponses = {
    /**
     * OK
     */
    200: ModelsGetResponse;
};

export type PutModelsByIdResponse = PutModelsByIdResponses[keyof PutModelsByIdResponses];

export type PostModelsByIdTestData = {
    body?: never;
    path: {
        /**
         * Model internal ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/models/{id}/test';
};

export type PostModelsByIdTestErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostModelsByIdTestError = PostModelsByIdTestErrors[keyof PostModelsByIdTestErrors];

export type PostModelsByIdTestResponses = {
    /**
     * OK
     */
    200: ModelsTestResponse;
};

export type PostModelsByIdTestResponse = PostModelsByIdTestResponses[keyof PostModelsByIdTestResponses];

export type GetPingData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/ping';
};

export type GetPingResponses = {
    /**
     * OK
     */
    200: HandlersPingResponse;
};

export type GetPingResponse = GetPingResponses[keyof GetPingResponses];

export type GetProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/providers';
};

export type GetProvidersErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetProvidersError = GetProvidersErrors[keyof GetProvidersErrors];

export type GetProvidersResponses = {
    /**
     * OK
     */
    200: Array<ProvidersGetResponse>;
};

export type GetProvidersResponse = GetProvidersResponses[keyof GetProvidersResponses];

export type PostProvidersData = {
    /**
     * Provider configuration
     */
    body: ProvidersCreateRequest;
    path?: never;
    query?: never;
    url: '/providers';
};

export type PostProvidersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostProvidersError = PostProvidersErrors[keyof PostProvidersErrors];

export type PostProvidersResponses = {
    /**
     * Created
     */
    201: ProvidersGetResponse;
};

export type PostProvidersResponse = PostProvidersResponses[keyof PostProvidersResponses];

export type GetProvidersCountData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/providers/count';
};

export type GetProvidersCountErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetProvidersCountError = GetProvidersCountErrors[keyof GetProvidersCountErrors];

export type GetProvidersCountResponses = {
    /**
     * OK
     */
    200: ProvidersCountResponse;
};

export type GetProvidersCountResponse = GetProvidersCountResponses[keyof GetProvidersCountResponses];

export type GetProvidersNameByNameData = {
    body?: never;
    path: {
        /**
         * Provider name
         */
        name: string;
    };
    query?: never;
    url: '/providers/name/{name}';
};

export type GetProvidersNameByNameErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetProvidersNameByNameError = GetProvidersNameByNameErrors[keyof GetProvidersNameByNameErrors];

export type GetProvidersNameByNameResponses = {
    /**
     * OK
     */
    200: ProvidersGetResponse;
};

export type GetProvidersNameByNameResponse = GetProvidersNameByNameResponses[keyof GetProvidersNameByNameResponses];

export type DeleteProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/providers/{id}';
};

export type DeleteProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteProvidersByIdError = DeleteProvidersByIdErrors[keyof DeleteProvidersByIdErrors];

export type DeleteProvidersByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/providers/{id}';
};

export type GetProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetProvidersByIdError = GetProvidersByIdErrors[keyof GetProvidersByIdErrors];

export type GetProvidersByIdResponses = {
    /**
     * OK
     */
    200: ProvidersGetResponse;
};

export type GetProvidersByIdResponse = GetProvidersByIdResponses[keyof GetProvidersByIdResponses];

export type PutProvidersByIdData = {
    /**
     * Updated provider configuration
     */
    body: ProvidersUpdateRequest;
    path: {
        /**
         * Provider ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/providers/{id}';
};

export type PutProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutProvidersByIdError = PutProvidersByIdErrors[keyof PutProvidersByIdErrors];

export type PutProvidersByIdResponses = {
    /**
     * OK
     */
    200: ProvidersGetResponse;
};

export type PutProvidersByIdResponse = PutProvidersByIdResponses[keyof PutProvidersByIdResponses];

export type PostProvidersByIdImportModelsData = {
    body?: never;
    path: {
        /**
         * Provider ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/providers/{id}/import-models';
};

export type PostProvidersByIdImportModelsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostProvidersByIdImportModelsError = PostProvidersByIdImportModelsErrors[keyof PostProvidersByIdImportModelsErrors];

export type PostProvidersByIdImportModelsResponses = {
    /**
     * OK
     */
    200: ProvidersImportModelsResponse;
};

export type PostProvidersByIdImportModelsResponse = PostProvidersByIdImportModelsResponses[keyof PostProvidersByIdImportModelsResponses];

export type GetProvidersByIdModelsData = {
    body?: never;
    path: {
        /**
         * Provider ID (UUID)
         */
        id: string;
    };
    query?: {
        /**
         * Model type (chat, embedding)
         */
        type?: string;
    };
    url: '/providers/{id}/models';
};

export type GetProvidersByIdModelsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetProvidersByIdModelsError = GetProvidersByIdModelsErrors[keyof GetProvidersByIdModelsErrors];

export type GetProvidersByIdModelsResponses = {
    /**
     * OK
     */
    200: Array<ModelsGetResponse>;
};

export type GetProvidersByIdModelsResponse = GetProvidersByIdModelsResponses[keyof GetProvidersByIdModelsResponses];

export type PostProvidersByIdTestData = {
    body?: never;
    path: {
        /**
         * Provider ID (UUID)
         */
        id: string;
    };
    query?: never;
    url: '/providers/{id}/test';
};

export type PostProvidersByIdTestErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostProvidersByIdTestError = PostProvidersByIdTestErrors[keyof PostProvidersByIdTestErrors];

export type PostProvidersByIdTestResponses = {
    /**
     * OK
     */
    200: ProvidersTestResponse;
};

export type PostProvidersByIdTestResponse = PostProvidersByIdTestResponses[keyof PostProvidersByIdTestResponses];

export type GetSearchProvidersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Provider filter (brave)
         */
        provider?: string;
    };
    url: '/search-providers';
};

export type GetSearchProvidersErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetSearchProvidersError = GetSearchProvidersErrors[keyof GetSearchProvidersErrors];

export type GetSearchProvidersResponses = {
    /**
     * OK
     */
    200: Array<SearchprovidersGetResponse>;
};

export type GetSearchProvidersResponse = GetSearchProvidersResponses[keyof GetSearchProvidersResponses];

export type PostSearchProvidersData = {
    /**
     * Search provider configuration
     */
    body: SearchprovidersCreateRequest;
    path?: never;
    query?: never;
    url: '/search-providers';
};

export type PostSearchProvidersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostSearchProvidersError = PostSearchProvidersErrors[keyof PostSearchProvidersErrors];

export type PostSearchProvidersResponses = {
    /**
     * Created
     */
    201: SearchprovidersGetResponse;
};

export type PostSearchProvidersResponse = PostSearchProvidersResponses[keyof PostSearchProvidersResponses];

export type GetSearchProvidersMetaData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/search-providers/meta';
};

export type GetSearchProvidersMetaResponses = {
    /**
     * OK
     */
    200: Array<SearchprovidersProviderMeta>;
};

export type GetSearchProvidersMetaResponse = GetSearchProvidersMetaResponses[keyof GetSearchProvidersMetaResponses];

export type DeleteSearchProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/search-providers/{id}';
};

export type DeleteSearchProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteSearchProvidersByIdError = DeleteSearchProvidersByIdErrors[keyof DeleteSearchProvidersByIdErrors];

export type DeleteSearchProvidersByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetSearchProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/search-providers/{id}';
};

export type GetSearchProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetSearchProvidersByIdError = GetSearchProvidersByIdErrors[keyof GetSearchProvidersByIdErrors];

export type GetSearchProvidersByIdResponses = {
    /**
     * OK
     */
    200: SearchprovidersGetResponse;
};

export type GetSearchProvidersByIdResponse = GetSearchProvidersByIdResponses[keyof GetSearchProvidersByIdResponses];

export type PutSearchProvidersByIdData = {
    /**
     * Updated configuration
     */
    body: SearchprovidersUpdateRequest;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/search-providers/{id}';
};

export type PutSearchProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutSearchProvidersByIdError = PutSearchProvidersByIdErrors[keyof PutSearchProvidersByIdErrors];

export type PutSearchProvidersByIdResponses = {
    /**
     * OK
     */
    200: SearchprovidersGetResponse;
};

export type PutSearchProvidersByIdResponse = PutSearchProvidersByIdResponses[keyof PutSearchProvidersByIdResponses];

export type GetTtsModelsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/tts-models';
};

export type GetTtsModelsErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetTtsModelsError = GetTtsModelsErrors[keyof GetTtsModelsErrors];

export type GetTtsModelsResponses = {
    /**
     * OK
     */
    200: Array<TtsModelResponse>;
};

export type GetTtsModelsResponse = GetTtsModelsResponses[keyof GetTtsModelsResponses];

export type PostTtsModelsData = {
    /**
     * TTS model configuration
     */
    body: TtsCreateModelRequest;
    path?: never;
    query?: never;
    url: '/tts-models';
};

export type PostTtsModelsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostTtsModelsError = PostTtsModelsErrors[keyof PostTtsModelsErrors];

export type PostTtsModelsResponses = {
    /**
     * Created
     */
    201: TtsModelResponse;
};

export type PostTtsModelsResponse = PostTtsModelsResponses[keyof PostTtsModelsResponses];

export type DeleteTtsModelsByIdData = {
    body?: never;
    path: {
        /**
         * Model ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-models/{id}';
};

export type DeleteTtsModelsByIdErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteTtsModelsByIdError = DeleteTtsModelsByIdErrors[keyof DeleteTtsModelsByIdErrors];

export type DeleteTtsModelsByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetTtsModelsByIdData = {
    body?: never;
    path: {
        /**
         * Model ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-models/{id}';
};

export type GetTtsModelsByIdErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetTtsModelsByIdError = GetTtsModelsByIdErrors[keyof GetTtsModelsByIdErrors];

export type GetTtsModelsByIdResponses = {
    /**
     * OK
     */
    200: TtsModelResponse;
};

export type GetTtsModelsByIdResponse = GetTtsModelsByIdResponses[keyof GetTtsModelsByIdResponses];

export type PutTtsModelsByIdData = {
    /**
     * Updated configuration
     */
    body: TtsUpdateModelRequest;
    path: {
        /**
         * Model ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-models/{id}';
};

export type PutTtsModelsByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutTtsModelsByIdError = PutTtsModelsByIdErrors[keyof PutTtsModelsByIdErrors];

export type PutTtsModelsByIdResponses = {
    /**
     * OK
     */
    200: TtsModelResponse;
};

export type PutTtsModelsByIdResponse = PutTtsModelsByIdResponses[keyof PutTtsModelsByIdResponses];

export type GetTtsModelsByIdCapabilitiesData = {
    body?: never;
    path: {
        /**
         * Model ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-models/{id}/capabilities';
};

export type GetTtsModelsByIdCapabilitiesErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetTtsModelsByIdCapabilitiesError = GetTtsModelsByIdCapabilitiesErrors[keyof GetTtsModelsByIdCapabilitiesErrors];

export type GetTtsModelsByIdCapabilitiesResponses = {
    /**
     * OK
     */
    200: TtsModelCapabilities;
};

export type GetTtsModelsByIdCapabilitiesResponse = GetTtsModelsByIdCapabilitiesResponses[keyof GetTtsModelsByIdCapabilitiesResponses];

export type PostTtsModelsByIdTestData = {
    /**
     * Text to synthesize
     */
    body: TtsTestSynthesizeRequest;
    path: {
        /**
         * Model ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-models/{id}/test';
};

export type PostTtsModelsByIdTestErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostTtsModelsByIdTestError = PostTtsModelsByIdTestErrors[keyof PostTtsModelsByIdTestErrors];

export type PostTtsModelsByIdTestResponses = {
    /**
     * Audio data
     */
    200: unknown;
};

export type GetTtsProvidersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Provider type filter
         */
        provider?: string;
    };
    url: '/tts-providers';
};

export type GetTtsProvidersErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetTtsProvidersError = GetTtsProvidersErrors[keyof GetTtsProvidersErrors];

export type GetTtsProvidersResponses = {
    /**
     * OK
     */
    200: Array<TtsProviderResponse>;
};

export type GetTtsProvidersResponse = GetTtsProvidersResponses[keyof GetTtsProvidersResponses];

export type PostTtsProvidersData = {
    /**
     * TTS provider configuration
     */
    body: TtsCreateProviderRequest;
    path?: never;
    query?: never;
    url: '/tts-providers';
};

export type PostTtsProvidersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostTtsProvidersError = PostTtsProvidersErrors[keyof PostTtsProvidersErrors];

export type PostTtsProvidersResponses = {
    /**
     * Created
     */
    201: TtsProviderResponse;
};

export type PostTtsProvidersResponse = PostTtsProvidersResponses[keyof PostTtsProvidersResponses];

export type GetTtsProvidersMetaData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/tts-providers/meta';
};

export type GetTtsProvidersMetaResponses = {
    /**
     * OK
     */
    200: Array<TtsProviderMetaResponse>;
};

export type GetTtsProvidersMetaResponse = GetTtsProvidersMetaResponses[keyof GetTtsProvidersMetaResponses];

export type DeleteTtsProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-providers/{id}';
};

export type DeleteTtsProvidersByIdErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type DeleteTtsProvidersByIdError = DeleteTtsProvidersByIdErrors[keyof DeleteTtsProvidersByIdErrors];

export type DeleteTtsProvidersByIdResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetTtsProvidersByIdData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-providers/{id}';
};

export type GetTtsProvidersByIdErrors = {
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
};

export type GetTtsProvidersByIdError = GetTtsProvidersByIdErrors[keyof GetTtsProvidersByIdErrors];

export type GetTtsProvidersByIdResponses = {
    /**
     * OK
     */
    200: TtsProviderResponse;
};

export type GetTtsProvidersByIdResponse = GetTtsProvidersByIdResponses[keyof GetTtsProvidersByIdResponses];

export type PutTtsProvidersByIdData = {
    /**
     * Updated configuration
     */
    body: TtsUpdateProviderRequest;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-providers/{id}';
};

export type PutTtsProvidersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutTtsProvidersByIdError = PutTtsProvidersByIdErrors[keyof PutTtsProvidersByIdErrors];

export type PutTtsProvidersByIdResponses = {
    /**
     * OK
     */
    200: TtsProviderResponse;
};

export type PutTtsProvidersByIdResponse = PutTtsProvidersByIdResponses[keyof PutTtsProvidersByIdResponses];

export type PostTtsProvidersByIdImportModelsData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-providers/{id}/import-models';
};

export type PostTtsProvidersByIdImportModelsErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostTtsProvidersByIdImportModelsError = PostTtsProvidersByIdImportModelsErrors[keyof PostTtsProvidersByIdImportModelsErrors];

export type PostTtsProvidersByIdImportModelsResponses = {
    /**
     * OK
     */
    200: Array<TtsModelResponse>;
};

export type PostTtsProvidersByIdImportModelsResponse = PostTtsProvidersByIdImportModelsResponses[keyof PostTtsProvidersByIdImportModelsResponses];

export type GetTtsProvidersByIdModelsData = {
    body?: never;
    path: {
        /**
         * Provider ID
         */
        id: string;
    };
    query?: never;
    url: '/tts-providers/{id}/models';
};

export type GetTtsProvidersByIdModelsErrors = {
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetTtsProvidersByIdModelsError = GetTtsProvidersByIdModelsErrors[keyof GetTtsProvidersByIdModelsErrors];

export type GetTtsProvidersByIdModelsResponses = {
    /**
     * OK
     */
    200: Array<TtsModelResponse>;
};

export type GetTtsProvidersByIdModelsResponse = GetTtsProvidersByIdModelsResponses[keyof GetTtsProvidersByIdModelsResponses];

export type GetUsersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/users';
};

export type GetUsersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetUsersError = GetUsersErrors[keyof GetUsersErrors];

export type GetUsersResponses = {
    /**
     * OK
     */
    200: AccountsListAccountsResponse;
};

export type GetUsersResponse = GetUsersResponses[keyof GetUsersResponses];

export type PostUsersData = {
    /**
     * User payload
     */
    body: AccountsCreateAccountRequest;
    path?: never;
    query?: never;
    url: '/users';
};

export type PostUsersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PostUsersError = PostUsersErrors[keyof PostUsersErrors];

export type PostUsersResponses = {
    /**
     * Created
     */
    201: AccountsAccount;
};

export type PostUsersResponse = PostUsersResponses[keyof PostUsersResponses];

export type GetUsersMeData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/users/me';
};

export type GetUsersMeErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetUsersMeError = GetUsersMeErrors[keyof GetUsersMeErrors];

export type GetUsersMeResponses = {
    /**
     * OK
     */
    200: AccountsAccount;
};

export type GetUsersMeResponse = GetUsersMeResponses[keyof GetUsersMeResponses];

export type PutUsersMeData = {
    /**
     * Profile payload
     */
    body: AccountsUpdateProfileRequest;
    path?: never;
    query?: never;
    url: '/users/me';
};

export type PutUsersMeErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutUsersMeError = PutUsersMeErrors[keyof PutUsersMeErrors];

export type PutUsersMeResponses = {
    /**
     * OK
     */
    200: AccountsAccount;
};

export type PutUsersMeResponse = PutUsersMeResponses[keyof PutUsersMeResponses];

export type GetUsersMeChannelsByPlatformData = {
    body?: never;
    path: {
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/users/me/channels/{platform}';
};

export type GetUsersMeChannelsByPlatformErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetUsersMeChannelsByPlatformError = GetUsersMeChannelsByPlatformErrors[keyof GetUsersMeChannelsByPlatformErrors];

export type GetUsersMeChannelsByPlatformResponses = {
    /**
     * OK
     */
    200: ChannelChannelIdentityBinding;
};

export type GetUsersMeChannelsByPlatformResponse = GetUsersMeChannelsByPlatformResponses[keyof GetUsersMeChannelsByPlatformResponses];

export type PutUsersMeChannelsByPlatformData = {
    /**
     * Channel user config payload
     */
    body: ChannelUpsertChannelIdentityConfigRequest;
    path: {
        /**
         * Channel platform
         */
        platform: string;
    };
    query?: never;
    url: '/users/me/channels/{platform}';
};

export type PutUsersMeChannelsByPlatformErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutUsersMeChannelsByPlatformError = PutUsersMeChannelsByPlatformErrors[keyof PutUsersMeChannelsByPlatformErrors];

export type PutUsersMeChannelsByPlatformResponses = {
    /**
     * OK
     */
    200: ChannelChannelIdentityBinding;
};

export type PutUsersMeChannelsByPlatformResponse = PutUsersMeChannelsByPlatformResponses[keyof PutUsersMeChannelsByPlatformResponses];

export type GetUsersMeIdentitiesData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/users/me/identities';
};

export type GetUsersMeIdentitiesErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetUsersMeIdentitiesError = GetUsersMeIdentitiesErrors[keyof GetUsersMeIdentitiesErrors];

export type GetUsersMeIdentitiesResponses = {
    /**
     * OK
     */
    200: HandlersListMyIdentitiesResponse;
};

export type GetUsersMeIdentitiesResponse = GetUsersMeIdentitiesResponses[keyof GetUsersMeIdentitiesResponses];

export type PutUsersMePasswordData = {
    /**
     * Password payload
     */
    body: AccountsUpdatePasswordRequest;
    path?: never;
    query?: never;
    url: '/users/me/password';
};

export type PutUsersMePasswordErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutUsersMePasswordError = PutUsersMePasswordErrors[keyof PutUsersMePasswordErrors];

export type PutUsersMePasswordResponses = {
    /**
     * No Content
     */
    204: unknown;
};

export type GetUsersByIdData = {
    body?: never;
    path: {
        /**
         * User ID
         */
        id: string;
    };
    query?: never;
    url: '/users/{id}';
};

export type GetUsersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type GetUsersByIdError = GetUsersByIdErrors[keyof GetUsersByIdErrors];

export type GetUsersByIdResponses = {
    /**
     * OK
     */
    200: AccountsAccount;
};

export type GetUsersByIdResponse = GetUsersByIdResponses[keyof GetUsersByIdResponses];

export type PutUsersByIdData = {
    /**
     * User update payload
     */
    body: AccountsUpdateAccountRequest;
    path: {
        /**
         * User ID
         */
        id: string;
    };
    query?: never;
    url: '/users/{id}';
};

export type PutUsersByIdErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutUsersByIdError = PutUsersByIdErrors[keyof PutUsersByIdErrors];

export type PutUsersByIdResponses = {
    /**
     * OK
     */
    200: AccountsAccount;
};

export type PutUsersByIdResponse = PutUsersByIdResponses[keyof PutUsersByIdResponses];

export type PutUsersByIdPasswordData = {
    /**
     * Password payload
     */
    body: AccountsResetPasswordRequest;
    path: {
        /**
         * User ID
         */
        id: string;
    };
    query?: never;
    url: '/users/{id}/password';
};

export type PutUsersByIdPasswordErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Forbidden
     */
    403: HandlersErrorResponse;
    /**
     * Not Found
     */
    404: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
};

export type PutUsersByIdPasswordError = PutUsersByIdPasswordErrors[keyof PutUsersByIdPasswordErrors];

export type PutUsersByIdPasswordResponses = {
    /**
     * No Content
     */
    204: unknown;
};
