// 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 BotsBot = {
    allow_guest?: boolean;
    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;
    type?: 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 BotsBotMember = {
    bot_id?: string;
    created_at?: string;
    role?: string;
    user_id?: string;
};

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

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

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

export type BotsListMembersResponse = {
    items?: Array<BotsBotMember>;
};

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 BotsUpsertMemberRequest = {
    role?: string;
    user_id?: 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 GithubComMemohaiMemohInternalMcpConnection = {
    bot_id?: string;
    config?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    is_active?: boolean;
    name?: string;
    type?: string;
    updated_at?: string;
};

export type HandlersBatchDeleteRequest = {
    ids?: 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 = {
    snapshotter?: string;
};

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

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

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

export type HandlersEmbeddingsInput = {
    image_url?: string;
    text?: string;
    video_url?: string;
};

export type HandlersEmbeddingsRequest = {
    dimensions?: number;
    input?: HandlersEmbeddingsInput;
    model?: string;
    provider?: string;
    type?: string;
};

export type HandlersEmbeddingsResponse = {
    dimensions?: number;
    embedding?: Array<number>;
    message?: string;
    model?: string;
    provider?: string;
    type?: string;
    usage?: HandlersEmbeddingsUsage;
};

export type HandlersEmbeddingsUsage = {
    duration?: number;
    image_tokens?: number;
    input_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;
    host_path?: string;
    image?: string;
    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 HandlersSkillItem = {
    content?: string;
    description?: string;
    metadata?: {
        [key: string]: unknown;
    };
    name?: string;
};

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

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

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

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

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

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

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

export type HandlersMemoryAddPayload = {
    embedding_enabled?: boolean;
    filters?: {
        [key: string]: unknown;
    };
    infer?: boolean;
    message?: string;
    messages?: Array<MemoryMessage>;
    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 HandlersSkillsOpResponse = {
    ok?: boolean;
};

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 InboxCountResult = {
    total?: number;
    unread?: number;
};

export type InboxCreateRequest = {
    bot_id?: string;
    content?: {
        [key: string]: unknown;
    };
    source?: string;
};

export type InboxItem = {
    bot_id?: string;
    content?: {
        [key: string]: unknown;
    };
    created_at?: string;
    id?: string;
    is_read?: boolean;
    read_at?: string;
    source?: 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 McpUpsertRequest = {
    args?: Array<string>;
    command?: string;
    cwd?: string;
    env?: {
        [key: string]: string;
    };
    headers?: {
        [key: string]: string;
    };
    is_active?: boolean;
    name?: string;
    transport?: string;
    url?: string;
};

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

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

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

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

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

export type MemoryRebuildResult = {
    fs_count?: number;
    missing_count?: number;
    qdrant_count?: number;
    restored_count?: number;
};

export type MemorySearchResponse = {
    relations?: Array<unknown>;
    results?: Array<MemoryMemoryItem>;
};

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

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

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

export type MessageMessageAsset = {
    content_hash?: string;
    mime?: string;
    ordinal?: number;
    role?: string;
    size_bytes?: number;
    storage_key?: string;
};

export type ModelsAddRequest = {
    client_type?: ModelsClientType;
    dimensions?: number;
    input_modalities?: Array<string>;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

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

export type ModelsClientType = 'openai-responses' | 'openai-completions' | 'anthropic-messages' | 'google-generative-ai';

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

export type ModelsGetResponse = {
    client_type?: ModelsClientType;
    dimensions?: number;
    id?: string;
    input_modalities?: Array<string>;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

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

export type ModelsUpdateRequest = {
    client_type?: ModelsClientType;
    dimensions?: number;
    input_modalities?: Array<string>;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

export type ProvidersCheckResult = {
    latency_ms?: number;
    message?: string;
    status?: ProvidersCheckStatus;
    status_code?: number;
};

export type ProvidersCheckStatus = 'supported' | 'auth_error' | 'unsupported' | 'error';

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

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

export type ProvidersGetResponse = {
    /**
     * masked in response
     */
    api_key?: string;
    base_url?: string;
    created_at?: string;
    id?: string;
    metadata?: {
        [key: string]: unknown;
    };
    name?: string;
    updated_at?: string;
};

export type ProvidersTestResponse = {
    checks?: {
        [key: string]: ProvidersCheckResult;
    };
    latency_ms?: number;
    message?: string;
    reachable?: boolean;
};

export type ProvidersUpdateRequest = {
    api_key?: string;
    base_url?: 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 ScheduleListResponse = {
    items?: Array<ScheduleSchedule>;
};

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';

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

export type SettingsSettings = {
    allow_guest?: boolean;
    chat_model_id?: string;
    embedding_model_id?: string;
    language?: string;
    max_context_load_time?: number;
    max_context_tokens?: number;
    max_inbox_items?: number;
    memory_model_id?: string;
    search_provider_id?: string;
};

export type SettingsUpsertRequest = {
    allow_guest?: boolean;
    chat_model_id?: string;
    embedding_model_id?: string;
    language?: string;
    max_context_load_time?: number;
    max_context_tokens?: number;
    max_inbox_items?: number;
    memory_model_id?: string;
    search_provider_id?: string;
};

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

export type SubagentContextResponse = {
    messages?: Array<{
        [key: string]: unknown;
    }>;
    usage?: {
        [key: string]: unknown;
    };
};

export type SubagentCreateRequest = {
    description?: string;
    messages?: Array<{
        [key: string]: unknown;
    }>;
    metadata?: {
        [key: string]: unknown;
    };
    name?: string;
    skills?: Array<string>;
};

export type SubagentListResponse = {
    items?: Array<SubagentSubagent>;
};

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

export type SubagentSubagent = {
    bot_id?: string;
    created_at?: string;
    deleted?: boolean;
    deleted_at?: string;
    description?: string;
    id?: string;
    messages?: Array<{
        [key: string]: unknown;
    }>;
    metadata?: {
        [key: string]: unknown;
    };
    name?: string;
    skills?: Array<string>;
    updated_at?: string;
    usage?: {
        [key: string]: unknown;
    };
};

export type SubagentUpdateContextRequest = {
    messages?: Array<{
        [key: string]: unknown;
    }>;
    usage?: {
        [key: string]: unknown;
    };
};

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

export type SubagentUpdateSkillsRequest = {
    skills?: Array<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 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 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 DeleteBotsByBotIdContainerData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    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 = {
    /**
     * OK
     */
    200: HandlersCreateContainerResponse;
};

export type PostBotsByBotIdContainerResponse = PostBotsByBotIdContainerResponses[keyof PostBotsByBotIdContainerResponses];

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 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;
};

export type PostBotsByBotIdContainerSnapshotsError = PostBotsByBotIdContainerSnapshotsErrors[keyof PostBotsByBotIdContainerSnapshotsErrors];

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

export type PostBotsByBotIdContainerSnapshotsResponse = PostBotsByBotIdContainerSnapshotsResponses[keyof PostBotsByBotIdContainerSnapshotsResponses];

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 GetBotsByBotIdInboxData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Filter by read status (true/false)
         */
        is_read?: string;
        /**
         * Filter by source
         */
        source?: string;
        /**
         * Max items to return
         */
        limit?: number;
        /**
         * Offset for pagination
         */
        offset?: number;
    };
    url: '/bots/{bot_id}/inbox';
};

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

export type GetBotsByBotIdInboxError = GetBotsByBotIdInboxErrors[keyof GetBotsByBotIdInboxErrors];

export type GetBotsByBotIdInboxResponses = {
    /**
     * OK
     */
    200: Array<InboxItem>;
};

export type GetBotsByBotIdInboxResponse = GetBotsByBotIdInboxResponses[keyof GetBotsByBotIdInboxResponses];

export type PostBotsByBotIdInboxData = {
    /**
     * Inbox item payload
     */
    body: InboxCreateRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/inbox';
};

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

export type PostBotsByBotIdInboxError = PostBotsByBotIdInboxErrors[keyof PostBotsByBotIdInboxErrors];

export type PostBotsByBotIdInboxResponses = {
    /**
     * Created
     */
    201: InboxItem;
};

export type PostBotsByBotIdInboxResponse = PostBotsByBotIdInboxResponses[keyof PostBotsByBotIdInboxResponses];

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

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

export type GetBotsByBotIdInboxCountError = GetBotsByBotIdInboxCountErrors[keyof GetBotsByBotIdInboxCountErrors];

export type GetBotsByBotIdInboxCountResponses = {
    /**
     * OK
     */
    200: InboxCountResult;
};

export type GetBotsByBotIdInboxCountResponse = GetBotsByBotIdInboxCountResponses[keyof GetBotsByBotIdInboxCountResponses];

export type PostBotsByBotIdInboxMarkReadData = {
    /**
     * Item IDs to mark as read
     */
    body: HandlersMarkReadRequest;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/inbox/mark-read';
};

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

export type PostBotsByBotIdInboxMarkReadError = PostBotsByBotIdInboxMarkReadErrors[keyof PostBotsByBotIdInboxMarkReadErrors];

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

export type DeleteBotsByBotIdInboxByIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Inbox item ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/inbox/{id}';
};

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

export type DeleteBotsByBotIdInboxByIdError = DeleteBotsByBotIdInboxByIdErrors[keyof DeleteBotsByBotIdInboxByIdErrors];

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

export type GetBotsByBotIdInboxByIdData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
        /**
         * Inbox item ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/inbox/{id}';
};

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

export type GetBotsByBotIdInboxByIdError = GetBotsByBotIdInboxByIdErrors[keyof GetBotsByBotIdInboxByIdErrors];

export type GetBotsByBotIdInboxByIdResponses = {
    /**
     * OK
     */
    200: InboxItem;
};

export type GetBotsByBotIdInboxByIdResponse = GetBotsByBotIdInboxByIdResponses[keyof GetBotsByBotIdInboxByIdResponses];

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 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: MemoryDeleteResponse;
};

export type DeleteBotsByBotIdMemoryResponse = DeleteBotsByBotIdMemoryResponses[keyof DeleteBotsByBotIdMemoryResponses];

export type GetBotsByBotIdMemoryData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        bot_id: string;
    };
    query?: {
        /**
         * Skip sparse vector stats (top_k_buckets, cdf_curve) to reduce overhead
         */
        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: MemorySearchResponse;
};

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: MemorySearchResponse;
};

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: MemoryCompactResult;
};

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;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Service Unavailable
     */
    503: HandlersErrorResponse;
};

export type PostBotsByBotIdMemoryRebuildError = PostBotsByBotIdMemoryRebuildErrors[keyof PostBotsByBotIdMemoryRebuildErrors];

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

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: MemorySearchResponse;
};

export type PostBotsByBotIdMemorySearchResponse = PostBotsByBotIdMemorySearchResponses[keyof PostBotsByBotIdMemorySearchResponses];

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: MemoryUsageResponse;
};

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: MemoryDeleteResponse;
};

export type DeleteBotsByBotIdMemoryByIdResponse = DeleteBotsByBotIdMemoryByIdResponses[keyof DeleteBotsByBotIdMemoryByIdResponses];

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 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 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 GetBotsByBotIdSubagentsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/subagents';
};

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

export type GetBotsByBotIdSubagentsError = GetBotsByBotIdSubagentsErrors[keyof GetBotsByBotIdSubagentsErrors];

export type GetBotsByBotIdSubagentsResponses = {
    /**
     * OK
     */
    200: SubagentListResponse;
};

export type GetBotsByBotIdSubagentsResponse = GetBotsByBotIdSubagentsResponses[keyof GetBotsByBotIdSubagentsResponses];

export type PostBotsByBotIdSubagentsData = {
    /**
     * Subagent payload
     */
    body: SubagentCreateRequest;
    path?: never;
    query?: never;
    url: '/bots/{bot_id}/subagents';
};

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

export type PostBotsByBotIdSubagentsError = PostBotsByBotIdSubagentsErrors[keyof PostBotsByBotIdSubagentsErrors];

export type PostBotsByBotIdSubagentsResponses = {
    /**
     * Created
     */
    201: SubagentSubagent;
};

export type PostBotsByBotIdSubagentsResponse = PostBotsByBotIdSubagentsResponses[keyof PostBotsByBotIdSubagentsResponses];

export type DeleteBotsByBotIdSubagentsByIdData = {
    body?: never;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}';
};

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

export type DeleteBotsByBotIdSubagentsByIdError = DeleteBotsByBotIdSubagentsByIdErrors[keyof DeleteBotsByBotIdSubagentsByIdErrors];

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

export type GetBotsByBotIdSubagentsByIdData = {
    body?: never;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}';
};

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

export type GetBotsByBotIdSubagentsByIdError = GetBotsByBotIdSubagentsByIdErrors[keyof GetBotsByBotIdSubagentsByIdErrors];

export type GetBotsByBotIdSubagentsByIdResponses = {
    /**
     * OK
     */
    200: SubagentSubagent;
};

export type GetBotsByBotIdSubagentsByIdResponse = GetBotsByBotIdSubagentsByIdResponses[keyof GetBotsByBotIdSubagentsByIdResponses];

export type PutBotsByBotIdSubagentsByIdData = {
    /**
     * Subagent payload
     */
    body: SubagentUpdateRequest;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}';
};

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

export type PutBotsByBotIdSubagentsByIdError = PutBotsByBotIdSubagentsByIdErrors[keyof PutBotsByBotIdSubagentsByIdErrors];

export type PutBotsByBotIdSubagentsByIdResponses = {
    /**
     * OK
     */
    200: SubagentSubagent;
};

export type PutBotsByBotIdSubagentsByIdResponse = PutBotsByBotIdSubagentsByIdResponses[keyof PutBotsByBotIdSubagentsByIdResponses];

export type GetBotsByBotIdSubagentsByIdContextData = {
    body?: never;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}/context';
};

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

export type GetBotsByBotIdSubagentsByIdContextError = GetBotsByBotIdSubagentsByIdContextErrors[keyof GetBotsByBotIdSubagentsByIdContextErrors];

export type GetBotsByBotIdSubagentsByIdContextResponses = {
    /**
     * OK
     */
    200: SubagentContextResponse;
};

export type GetBotsByBotIdSubagentsByIdContextResponse = GetBotsByBotIdSubagentsByIdContextResponses[keyof GetBotsByBotIdSubagentsByIdContextResponses];

export type PutBotsByBotIdSubagentsByIdContextData = {
    /**
     * Context payload
     */
    body: SubagentUpdateContextRequest;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}/context';
};

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

export type PutBotsByBotIdSubagentsByIdContextError = PutBotsByBotIdSubagentsByIdContextErrors[keyof PutBotsByBotIdSubagentsByIdContextErrors];

export type PutBotsByBotIdSubagentsByIdContextResponses = {
    /**
     * OK
     */
    200: SubagentContextResponse;
};

export type PutBotsByBotIdSubagentsByIdContextResponse = PutBotsByBotIdSubagentsByIdContextResponses[keyof PutBotsByBotIdSubagentsByIdContextResponses];

export type GetBotsByBotIdSubagentsByIdSkillsData = {
    body?: never;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}/skills';
};

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

export type GetBotsByBotIdSubagentsByIdSkillsError = GetBotsByBotIdSubagentsByIdSkillsErrors[keyof GetBotsByBotIdSubagentsByIdSkillsErrors];

export type GetBotsByBotIdSubagentsByIdSkillsResponses = {
    /**
     * OK
     */
    200: SubagentSkillsResponse;
};

export type GetBotsByBotIdSubagentsByIdSkillsResponse = GetBotsByBotIdSubagentsByIdSkillsResponses[keyof GetBotsByBotIdSubagentsByIdSkillsResponses];

export type PostBotsByBotIdSubagentsByIdSkillsData = {
    /**
     * Skills payload
     */
    body: SubagentAddSkillsRequest;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}/skills';
};

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

export type PostBotsByBotIdSubagentsByIdSkillsError = PostBotsByBotIdSubagentsByIdSkillsErrors[keyof PostBotsByBotIdSubagentsByIdSkillsErrors];

export type PostBotsByBotIdSubagentsByIdSkillsResponses = {
    /**
     * OK
     */
    200: SubagentSkillsResponse;
};

export type PostBotsByBotIdSubagentsByIdSkillsResponse = PostBotsByBotIdSubagentsByIdSkillsResponses[keyof PostBotsByBotIdSubagentsByIdSkillsResponses];

export type PutBotsByBotIdSubagentsByIdSkillsData = {
    /**
     * Skills payload
     */
    body: SubagentUpdateSkillsRequest;
    path: {
        /**
         * Subagent ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{bot_id}/subagents/{id}/skills';
};

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

export type PutBotsByBotIdSubagentsByIdSkillsError = PutBotsByBotIdSubagentsByIdSkillsErrors[keyof PutBotsByBotIdSubagentsByIdSkillsErrors];

export type PutBotsByBotIdSubagentsByIdSkillsResponses = {
    /**
     * OK
     */
    200: SubagentSkillsResponse;
};

export type PutBotsByBotIdSubagentsByIdSkillsResponse = PutBotsByBotIdSubagentsByIdSkillsResponses[keyof PutBotsByBotIdSubagentsByIdSkillsResponses];

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 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 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 GetBotsByIdMembersData = {
    body?: never;
    path: {
        /**
         * Bot ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{id}/members';
};

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

export type GetBotsByIdMembersError = GetBotsByIdMembersErrors[keyof GetBotsByIdMembersErrors];

export type GetBotsByIdMembersResponses = {
    /**
     * OK
     */
    200: BotsListMembersResponse;
};

export type GetBotsByIdMembersResponse = GetBotsByIdMembersResponses[keyof GetBotsByIdMembersResponses];

export type PutBotsByIdMembersData = {
    /**
     * Member payload
     */
    body: BotsUpsertMemberRequest;
    path: {
        /**
         * Bot ID
         */
        id: string;
    };
    query?: never;
    url: '/bots/{id}/members';
};

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

export type PutBotsByIdMembersError = PutBotsByIdMembersErrors[keyof PutBotsByIdMembersErrors];

export type PutBotsByIdMembersResponses = {
    /**
     * OK
     */
    200: BotsBotMember;
};

export type PutBotsByIdMembersResponse = PutBotsByIdMembersResponses[keyof PutBotsByIdMembersResponses];

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

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

export type DeleteBotsByIdMembersByUserIdError = DeleteBotsByIdMembersByUserIdErrors[keyof DeleteBotsByIdMembersByUserIdErrors];

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

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 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 PostEmbeddingsData = {
    /**
     * Embeddings request
     */
    body: HandlersEmbeddingsRequest;
    path?: never;
    query?: never;
    url: '/embeddings';
};

export type PostEmbeddingsErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * Internal Server Error
     */
    500: HandlersErrorResponse;
    /**
     * Not Implemented
     */
    501: HandlersEmbeddingsResponse;
};

export type PostEmbeddingsError = PostEmbeddingsErrors[keyof PostEmbeddingsErrors];

export type PostEmbeddingsResponses = {
    /**
     * OK
     */
    200: HandlersEmbeddingsResponse;
};

export type PostEmbeddingsResponse = PostEmbeddingsResponses[keyof PostEmbeddingsResponses];

export type GetModelsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Model type (chat, embedding)
         */
        type?: string;
        /**
         * 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 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 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 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;
};
