// 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 = {
    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 = {
    check_key?: string;
    detail?: string;
    metadata?: {
        [key: string]: unknown;
    };
    status?: string;
    summary?: 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 = {
    caption?: 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 = {
    botID?: string;
    channelType?: string;
    createdAt?: string;
    credentials?: {
        [key: string]: unknown;
    };
    externalIdentity?: string;
    id?: string;
    routing?: {
        [key: string]: unknown;
    };
    selfIdentity?: {
        [key: string]: unknown;
    };
    status?: string;
    updatedAt?: string;
    verifiedAt?: string;
};

export type ChannelChannelIdentityBinding = {
    channelIdentityID?: string;
    channelType?: string;
    config?: {
        [key: string]: unknown;
    };
    createdAt?: string;
    id?: string;
    updatedAt?: 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 ChannelUpsertChannelIdentityConfigRequest = {
    config?: {
        [key: string]: unknown;
    };
};

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

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

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 = {
    image_tokens?: number;
    input_tokens?: number;
    video_tokens?: number;
};

export type HandlersErrorResponse = {
    message?: 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 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;
    };
    name?: string;
    parent?: string;
    snapshotter?: string;
    updated_at?: string;
};

export type HandlersListMyIdentitiesResponse = {
    items?: Array<IdentitiesChannelIdentity>;
    user_id?: 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 McpListResponse = {
    items?: Array<GithubComMemohaiMemohInternalMcpConnection>;
};

export type McpUpsertRequest = {
    active?: boolean;
    config?: {
        [key: string]: unknown;
    };
    name?: string;
    type?: string;
};

export type ModelsAddRequest = {
    dimensions?: number;
    input?: Array<string>;
    is_multimodal?: boolean;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

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

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

export type ModelsGetResponse = {
    dimensions?: number;
    input?: Array<string>;
    is_multimodal?: boolean;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

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

export type ModelsUpdateRequest = {
    dimensions?: number;
    input?: Array<string>;
    is_multimodal?: boolean;
    llm_provider_id?: string;
    model_id?: string;
    name?: string;
    type?: ModelsModelType;
};

export type ProvidersClientType = 'openai' | 'openai-compat' | 'anthropic' | 'google' | 'azure' | 'bedrock' | 'mistral' | 'xai' | 'ollama' | 'dashscope';

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

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

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

export type ProvidersUpdateRequest = {
    api_key?: string;
    base_url?: string;
    client_type?: ProvidersClientType;
    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 SettingsSettings = {
    allow_guest?: boolean;
    chat_model_id?: string;
    embedding_model_id?: string;
    language?: string;
    max_context_load_time?: number;
    memory_model_id?: string;
};

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

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

export type SubagentContextResponse = {
    messages?: Array<{
        [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;
};

export type SubagentUpdateContextRequest = {
    messages?: Array<{
        [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 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 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 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 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 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 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 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 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 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, openai-compat, anthropic, google, azure, bedrock, mistral, xai, ollama, dashscope)
         */
        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?: {
        /**
         * Client type filter (openai, openai-compat, anthropic, google, azure, bedrock, mistral, xai, ollama, dashscope)
         */
        client_type?: string;
    };
    url: '/providers';
};

export type GetProvidersErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * 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?: {
        /**
         * Client type filter (openai, openai-compat, anthropic, google, azure, bedrock, mistral, xai, ollama, dashscope)
         */
        client_type?: string;
    };
    url: '/providers/count';
};

export type GetProvidersCountErrors = {
    /**
     * Bad Request
     */
    400: HandlersErrorResponse;
    /**
     * 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 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;
};
