Interface APIRoutes

interface APIRoutes {
    applications: (
        id: string,
    ) => {
        "activity-instances": (
            id: string,
        ) => {
            get(
                args?: RestArgumentsNoBody,
            ): Promise<RestGetAPIApplicationActivityInstanceResult>;
        };
        commands: {
            get(
                args?: RestArgumentsNoBody<RESTGetAPIApplicationCommandsQuery>,
            ): Promise<RESTGetAPIApplicationCommandsResult>;
            post(
                args: RestArguments<RESTPostAPIApplicationCommandsJSONBody>,
            ): Promise<APIApplicationCommand>;
            put(
                args?: RestArguments<RESTPutAPIApplicationCommandsJSONBody>,
            ): Promise<RESTPutAPIApplicationCommandsResult>;
            (
                id: string,
            ): {
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                get(args?: RestArgumentsNoBody): Promise<APIApplicationCommand>;
                patch(
                    args: RestArguments<RESTPatchAPIApplicationCommandJSONBody>,
                ): Promise<APIApplicationCommand>;
            };
        };
        emojis: {
            get(
                args?: RestArgumentsNoBody<Pick<APIApplicationEmoji, "id">>,
            ): Promise<RESTGetAPIApplicationEmojisResult>;
            post(
                args?: RestArguments<RESTPostAPIApplicationEmojiJSONBody>,
            ): Promise<APIApplicationEmoji>;
            (
                id: string,
            ): {
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                get(args?: RestArgumentsNoBody): Promise<APIApplicationEmoji>;
                patch(
                    args?: RestArguments<RESTPatchAPIApplicationEmojiJSONBody>,
                ): Promise<APIApplicationEmoji>;
            };
        };
        entitlements: {
            get(
                args?: RestArgumentsNoBody<RESTGetAPIEntitlementsQuery>,
            ): Promise<RESTGetAPIEntitlementsResult>;
            post(
                args: RestArguments<RESTPostAPIEntitlementBody>,
            ): Promise<Partial<Omit<APIEntitlement, "ends_at" | "starts_at">>>;
            (
                id: string,
            ): {
                consume: { post(args?: RestArgumentsNoBody): Promise<undefined> };
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                get(args?: RestArgumentsNoBody): Promise<APIEntitlement>;
            };
        };
        guilds: (
            id: string,
        ) => {
            commands: {
                permissions: {
                    get(
                        args?: RestArgumentsNoBody,
                    ): Promise<RESTGetAPIGuildApplicationCommandsPermissionsResult>;
                };
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIApplicationCommandsQuery>,
                ): Promise<RESTGetAPIApplicationGuildCommandsResult>;
                post(
                    args: RestArguments<RESTPostAPIApplicationGuildCommandsJSONBody>,
                ): Promise<RESTAPIApplicationGuildCommand>;
                put(
                    args?: RestArguments<RESTPutAPIApplicationGuildCommandsJSONBody>,
                ): Promise<RESTPutAPIApplicationGuildCommandsResult>;
                (
                    id: string,
                ): {
                    permissions: {
                        get(
                            args?: RestArgumentsNoBody,
                        ): Promise<RESTGetAPIGuildApplicationCommandsPermissionsResult>;
                        put(
                            args?: RestArguments<
                                RESTPutAPIApplicationCommandPermissionsJSONBody,
                            >,
                        ): Promise<RESTPutAPIGuildApplicationCommandsPermissionsResult>;
                    };
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(
                        args?: RestArgumentsNoBody,
                    ): Promise<RESTAPIApplicationGuildCommand>;
                    patch(
                        args: RestArguments<RESTPatchAPIApplicationGuildCommandJSONBody>,
                    ): Promise<RESTAPIApplicationGuildCommand>;
                };
            };
        };
        "role-connections": {
            metadata: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIApplicationRoleConnectionMetadataResult>;
                put(
                    args: RestArguments<
                        RESTPutAPIApplicationRoleConnectionMetadataJSONBody,
                    >,
                ): Promise<RESTPutAPIApplicationRoleConnectionMetadataResult>;
            };
        };
        skus: { get(args?: RestArgumentsNoBody): Promise<RESTGetAPISKUsResult> };
        get(args?: RestArgumentsNoBody): Promise<APIApplication>;
        patch(
            args: RestArguments<
                AddUndefinedToPossiblyUndefinedPropertiesOfInterface<
                    Partial<
                        Nullable<Pick<APIApplication, "icon" | "cover_image">> & Pick<
                            APIApplication,
                            | "description"
                            | "tags"
                            | "flags"
                            | "interactions_endpoint_url"
                            | "role_connections_verification_url"
                            | "install_params"
                            | "integration_types_config"
                            | "custom_install_url",
                        >,
                    >,
                >,
            >,
        ): Promise<APIApplication>;
    };
    gateway: {
        bot: { get(args?: RestArgumentsNoBody): Promise<APIGatewayBotInfo> };
        get(args?: RestArgumentsNoBody): Promise<APIGatewayInfo>;
    };
    guilds: {
        post(args: RestArguments<RESTPostAPIGuildsJSONBody>): Promise<APIGuild>;
        templates(
            code: string,
        ): {
            get(args?: RestArgumentsNoBody): Promise<APITemplate>;
            post(
                args: RestArguments<RESTPostAPITemplateCreateGuildJSONBody>,
            ): Promise<APIGuild>;
        };
        (
            id: string,
        ): {
            "audit-logs": {
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIAuditLogQuery>,
                ): Promise<APIAuditLog>;
            };
            "auto-moderation": {
                rules: {
                    get(
                        args?: RestArgumentsNoBody,
                    ): Promise<RESTGetAPIAutoModerationRulesResult>;
                    post(
                        args: RestArguments<RESTPostAPIAutoModerationRuleJSONBody>,
                    ): Promise<APIAutoModerationRule>;
                    (
                        id: string,
                    ): {
                        delete(args?: RestArgumentsNoBody): Promise<undefined>;
                        get(args?: RestArgumentsNoBody): Promise<APIAutoModerationRule>;
                        patch(
                            args: RestArguments<RESTPatchAPIAutoModerationRuleJSONBody>,
                        ): Promise<APIAutoModerationRule>;
                    };
                };
            };
            bans: {
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIGuildBansQuery>,
                ): Promise<RESTGetAPIGuildBansResult>;
                (
                    userId: string,
                ): {
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(args?: RestArgumentsNoBody): Promise<APIBan>;
                    put(
                        args?: RestArguments<undefined | RESTPutAPIGuildBanJSONBody>,
                    ): Promise<undefined>;
                };
            };
            "bulk-bans": {
                post(
                    args: RestArguments<RESTPostAPIGuildBulkBanJSONBody>,
                ): Promise<RESTPostAPIGuildBulkBanResult>;
            };
            channels: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildChannelsResult>;
                patch(
                    args: RestArguments<RESTPatchAPIGuildChannelPositionsJSONBody>,
                ): Promise<undefined>;
                post(
                    args: RestArguments<RESTPostAPIGuildChannelJSONBody>,
                ): Promise<APIChannel>;
            };
            emojis: {
                get(args?: RestArgumentsNoBody): Promise<RESTGetAPIGuildEmojisResult>;
                post(
                    args: RestArguments<RESTPostAPIGuildEmojiJSONBody>,
                ): Promise<APIEmoji>;
                (
                    id: string,
                ): {
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(args?: RestArgumentsNoBody): Promise<APIEmoji>;
                    patch(
                        args: RestArguments<RESTPatchAPIGuildEmojiJSONBody>,
                    ): Promise<APIEmoji>;
                };
            };
            integrations: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildIntegrationsResult>;
                (id: string): { delete(args?: RestArgumentsNoBody): Promise<undefined> };
            };
            invites: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildInvitesResult>;
            };
            members: {
                "@me": {
                    patch(
                        args: RestArguments<RESTPatchAPICurrentGuildMemberJSONBody>,
                    ): Promise<APIGuildMember>;
                };
                search: {
                    get(
                        args: RestArgumentsNoBody<RESTGetAPIGuildMembersSearchQuery>,
                    ): Promise<RESTGetAPIGuildMembersSearchResult>;
                };
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIGuildMembersQuery>,
                ): Promise<RESTGetAPIGuildMembersResult>;
                (
                    id: string,
                ): {
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(args?: RestArgumentsNoBody): Promise<APIGuildMember>;
                    patch(
                        args: RestArguments<RESTPatchAPIGuildMemberJSONBody>,
                    ): Promise<APIGuildMember>;
                    put(
                        args?: RestArguments<RESTPutAPIGuildMemberJSONBody>,
                    ): Promise<RESTPutAPIGuildMemberResult>;
                    roles(
                        id: string,
                    ): {
                        delete(args?: RestArgumentsNoBody): Promise<undefined>;
                        put(args?: RestArgumentsNoBody): Promise<undefined>;
                    };
                };
            };
            mfa: {
                post(
                    args: RestArguments<RESTPostAPIGuildsMFAJSONBody>,
                ): Promise<RESTPostAPIGuildsMFAJSONBody>;
            };
            preview: { get(args?: RestArgumentsNoBody): Promise<APIGuildPreview> };
            prune: {
                get(
                    args: RestArgumentsNoBody<RESTGetAPIGuildPruneCountQuery>,
                ): Promise<RESTGetAPIGuildPruneCountResult>;
                post(
                    args: RestArguments<RESTPostAPIGuildPruneJSONBody>,
                ): Promise<RESTPostAPIGuildPruneResult>;
            };
            regions: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildVoiceRegionsResult>;
            };
            roles: {
                get(args?: RestArgumentsNoBody): Promise<RESTGetAPIGuildRolesResult>;
                patch(
                    args: RestArguments<RESTPatchAPIGuildRolePositionsJSONBody>,
                ): Promise<RESTPatchAPIGuildRolePositionsResult>;
                post(
                    args: RestArguments<RESTPostAPIGuildRoleJSONBody>,
                ): Promise<APIRole>;
                (
                    id: string,
                ): {
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(args?: RestArgumentsNoBody): Promise<APIRole>;
                    patch(
                        args: RestArguments<RESTPatchAPIGuildRoleJSONBody>,
                    ): Promise<APIRole>;
                };
            };
            "scheduled-events": {
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIGuildScheduledEventsQuery>,
                ): Promise<RESTGetAPIGuildScheduledEventsResult>;
                post(
                    args: RestArguments<RESTPostAPIGuildScheduledEventJSONBody>,
                ): Promise<APIGuildScheduledEvent>;
                (
                    id: string,
                ): {
                    users: {
                        get(
                            args?: RestArgumentsNoBody<
                                RESTGetAPIGuildScheduledEventUsersQuery,
                            >,
                        ): Promise<RESTGetAPIGuildScheduledEventUsersResult>;
                    };
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(
                        args?: RestArgumentsNoBody<RESTGetAPIGuildScheduledEventQuery>,
                    ): Promise<APIGuildScheduledEvent>;
                    patch(
                        args: RestArguments<RESTPatchAPIGuildScheduledEventJSONBody>,
                    ): Promise<APIGuildScheduledEvent>;
                };
            };
            "soundboard-sounds": {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildSoundboardSoundsResult>;
                post(
                    args: RestArguments<RESTPostAPIGuildSoundboardSound>,
                ): Promise<APISoundBoard>;
                (
                    id: string,
                ): {
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(args?: RestArgumentsNoBody): Promise<APISoundBoard>;
                    patch(
                        args?: RestArguments<RESTPatchAPIGuildSoundboardSound>,
                    ): Promise<APISoundBoard>;
                };
            };
            stickers: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildStickersResult>;
                post(
                    args: RestArguments<
                        Omit<RESTPostAPIGuildStickerFormDataBody, "file">,
                        (Omit<RawFile, "key"> & { key: "file" })[],
                    >,
                ): Promise<APISticker>;
                (
                    id: string,
                ): {
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    get(args?: RestArgumentsNoBody): Promise<APISticker>;
                    patch(
                        args: RestArguments<RESTPatchAPIGuildStickerJSONBody>,
                    ): Promise<APISticker>;
                };
            };
            templates: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildTemplatesResult>;
                post(
                    args: RestArguments<RESTPostAPIGuildTemplatesJSONBody>,
                ): Promise<APITemplate>;
                (
                    code: string,
                ): {
                    delete(args?: RestArgumentsNoBody): Promise<APITemplate>;
                    patch(
                        args: RestArguments<
                            AddUndefinedToPossiblyUndefinedPropertiesOfInterface<
                                Partial<RESTPostAPIGuildTemplatesJSONBody>,
                            >,
                        >,
                    ): Promise<APITemplate>;
                    put(args?: RestArgumentsNoBody): Promise<APITemplate>;
                };
            };
            threads: {
                active: {
                    get(
                        args?: RestArgumentsNoBody,
                    ): Promise<
                        {
                            members: APIThreadMember[];
                            threads: APIChannel[] & Partial<APIThreadChannel>;
                        },
                    >;
                };
            };
            "vanity-url": {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildVanityUrlResult>;
            };
            "voice-states": {
                "@me": {
                    get(args?: RestArgumentsNoBody): Promise<APIVoiceState>;
                    patch(
                        args: RestArguments<
                            RESTPatchAPIGuildVoiceStateCurrentMemberJSONBody,
                        >,
                    ): Promise<undefined>;
                };
                (
                    userId: string,
                ): {
                    get(args?: RestArgumentsNoBody): Promise<APIVoiceState>;
                    patch(
                        args: RestArguments<RESTPatchAPIGuildVoiceStateUserJSONBody>,
                    ): Promise<undefined>;
                };
            };
            webhooks: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPIGuildWebhooksResult>;
            };
            "welcome-screen": {
                get(args?: RestArgumentsNoBody): Promise<APIGuildWelcomeScreen>;
                patch(
                    args: RestArguments<RESTPatchAPIGuildWelcomeScreenJSONBody>,
                ): Promise<APIGuildWelcomeScreen>;
            };
            widget: {
                get(
                    args?: RestArgumentsNoBody<{ style?: string }>,
                ): Promise<APIGuildWidgetSettings>;
                patch(
                    args: RestArguments<
                        AddUndefinedToPossiblyUndefinedPropertiesOfInterface<
                            Partial<APIGuildWidgetSettings>,
                        >,
                    >,
                ): Promise<APIGuildWidgetSettings>;
            };
            "widget.json": {
                get(args?: RestArgumentsNoBody): Promise<APIGuildWidget>;
            };
            "widget.png": {
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIGuildWidgetImageQuery>,
                ): Promise<ArrayBuffer>;
            };
            delete(args?: RestArgumentsNoBody): Promise<undefined>;
            get(args?: RestArgumentsNoBody<RESTGetAPIGuildQuery>): Promise<APIGuild>;
            patch(args: RestArguments<RESTPatchAPIGuildJSONBody>): Promise<APIGuild>;
        };
    };
    interactions: (
        id: string,
    ) => (
        token: string,
    ) => {
        callback: {
            post(
                args: RestArguments<
                    APIInteractionResponse,
                    Omit<RESTPostAPIInteractionCallbackQuery, "with_response"> & {
                        with_response: true;
                    },
                >,
            ): Promise<RESTPostAPIInteractionCallbackResult>;
            post(
                args: RestArguments<
                    APIInteractionResponse,
                    Omit<RESTPostAPIInteractionCallbackQuery, "with_response"> & {
                        with_response: false;
                    },
                >,
            ): Promise<undefined>;
            post(
                args: RestArguments<
                    APIInteractionResponse,
                    RESTPostAPIInteractionCallbackQuery,
                >,
            ): Promise<undefined | RESTPostAPIInteractionCallbackResult>;
        };
    };
    "soundboard-default-sounds": {
        get(
            args?: RestArgumentsNoBody,
        ): Promise<RESTGetAPIDefaultsSoundboardSoundsResult>;
    };
    "stage-instances": {
        post(
            args: RestArguments<RESTPostAPIStageInstanceJSONBody>,
        ): Promise<APIStageInstance>;
        (
            id: string,
        ): {
            delete(args?: RestArgumentsNoBody): Promise<undefined>;
            get(args?: RestArgumentsNoBody): Promise<APIStageInstance>;
            patch(
                args: RestArguments<RESTPatchAPIStageInstanceJSONBody>,
            ): Promise<APIStageInstance>;
        };
    };
    "sticker-packs": {
        get(args?: RestArgumentsNoBody): Promise<RESTGetStickerPacksResult>;
        (id: string): { get(args?: RestArgumentsNoBody): Promise<APIStickerPack> };
    };
    users: {
        (id: string): { get(args?: RestArgumentsNoBody): Promise<APIUser> };
        (
            id: "@me",
        ): {
            channels: {
                post(
                    args: RestArguments<RESTPostAPICurrentUserCreateDMChannelJSONBody>,
                ): Promise<APIDMChannel>;
            };
            connections: {
                get(
                    args?: RestArgumentsNoBody,
                ): Promise<RESTGetAPICurrentUserConnectionsResult>;
            };
            guilds: {
                get(
                    args?: RestArgumentsNoBody<RESTGetAPICurrentUserGuildsQuery>,
                ): Promise<RESTGetAPICurrentUserGuildsResult>;
                (
                    id: string,
                ): {
                    member: { get(args?: RestArgumentsNoBody): Promise<APIGuildMember> };
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                };
            };
            applications(
                applicationId: string,
            ): {
                "role-connection": {
                    get(
                        args?: RestArgumentsNoBody,
                    ): Promise<APIApplicationRoleConnection>;
                    put(
                        args: RestArguments<
                            RESTPutAPICurrentUserApplicationRoleConnectionJSONBody,
                        >,
                    ): Promise<APIApplicationRoleConnection>;
                };
            };
            get(args?: RestArgumentsNoBody): Promise<APIUser>;
            patch(
                args: RestArguments<RESTPatchAPICurrentUserJSONBody>,
            ): Promise<APIUser>;
        };
    };
    voice: {
        region: {
            get(args?: RestArgumentsNoBody): Promise<RESTGetAPIVoiceRegionsResult>;
        };
    };
    channels(
        id: string,
    ): {
        followers: {
            post(
                args: RestArguments<RESTPostAPIChannelFollowersJSONBody>,
            ): Promise<APIFollowedChannel>;
        };
        invites: {
            get(
                args?: RestArgumentsNoBody,
            ): Promise<RESTGetAPIChannelInvitesResult>;
            post(
                args: RestArguments<RESTPostAPIChannelInviteJSONBody>,
            ): Promise<APIExtendedInvite>;
        };
        messages: {
            "bulk-delete": {
                post(
                    args: RestArguments<RESTPostAPIChannelMessagesBulkDeleteJSONBody>,
                ): Promise<undefined>;
            };
            get(
                args?: RestArgumentsNoBody<RESTGetAPIChannelMessagesQuery>,
            ): Promise<RESTGetAPIChannelMessagesResult>;
            post(
                args: RestArguments<RESTPostAPIChannelMessageJSONBody>,
            ): Promise<APIMessage>;
            (
                id: string,
            ): {
                crosspost: { post(args: RestArgumentsNoBody): Promise<APIMessage> };
                reactions: {
                    delete(args?: RestArgumentsNoBody): Promise<undefined>;
                    (
                        emoji: string,
                    ): {
                        delete(args?: RestArgumentsNoBody): Promise<undefined>;
                        get(
                            args?: RestArgumentsNoBody<
                                RESTGetAPIChannelMessageReactionUsersQuery,
                            >,
                        ): Promise<RESTGetAPIChannelMessageReactionUsersResult>;
                        (
                            id: "@me",
                        ): {
                            delete(args?: RestArgumentsNoBody): Promise<undefined>;
                            put(args?: RestArgumentsNoBody): Promise<undefined>;
                        };
                        (
                            id: string,
                        ): { delete(args?: RestArgumentsNoBody): Promise<undefined> };
                    };
                };
                threads: {
                    post(
                        args: RestArguments<RESTPostAPIChannelMessagesThreadsJSONBody>,
                    ): Promise<APIChannel>;
                };
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                get(args?: RestArgumentsNoBody): Promise<APIMessage>;
                patch(
                    args: RestArguments<RESTPatchAPIChannelMessageJSONBody>,
                ): Promise<APIMessage>;
            };
        };
        permissions: (
            id: string,
        ) => {
            delete(args?: RestArgumentsNoBody): Promise<undefined>;
            put(
                args?: RestArguments<RESTPutAPIChannelPermissionJSONBody>,
            ): Promise<undefined>;
        };
        pins: {
            get(args?: RestArgumentsNoBody): Promise<RESTGetAPIChannelPinsResult>;
            (
                id: string,
            ): {
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                put(args?: RestArgumentsNoBody): Promise<undefined>;
            };
        };
        recipients: (
            id: string,
        ) => {
            delete(args?: RestArgumentsNoBody): Promise<unknown>;
            put(
                args?: RestArguments<RESTPutAPIChannelRecipientJSONBody>,
            ): Promise<unknown>;
        };
        "send-soundboard-sound": {
            post(
                args: RestArguments<RESTPostAPISendSoundboardSound>,
            ): Promise<undefined>;
        };
        "thread-members": {
            get(
                args?: RestArgumentsNoBody<RESTGetAPIChannelThreadMembersQuery>,
            ): Promise<RESTGetAPIChannelThreadMembersResult>;
            (
                id: "@me",
            ): {
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                put(args?: RestArgumentsNoBody): Promise<undefined>;
            };
            (
                id: string,
            ): {
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIChannelThreadMemberQuery>,
                ): Promise<APIThreadMember>;
                put(args?: RestArgumentsNoBody): Promise<undefined>;
            };
        };
        threads: {
            archived: {
                private: {
                    get(
                        args?: RestArgumentsNoBody<RESTGetAPIChannelThreadsArchivedQuery>,
                    ): Promise<RESTGetAPIChannelUsersThreadsArchivedResult>;
                };
                public: {
                    get(
                        args?: RestArgumentsNoBody<RESTGetAPIChannelThreadsArchivedQuery>,
                    ): Promise<RESTGetAPIChannelUsersThreadsArchivedResult>;
                };
            };
            post(
                args: RestArguments<
                    | RESTPostAPIGuildForumThreadsJSONBody
                    | RESTPostAPIChannelThreadsJSONBody,
                >,
            ): Promise<APIChannel>;
        };
        typing: { post(args?: RestArgumentsNoBody): Promise<undefined> };
        users: (
            id: "@me",
        ) => {
            threads: {
                archived: {
                    private: {
                        get(
                            args?: RestArgumentsNoBody<RESTGetAPIChannelThreadsArchivedQuery>,
                        ): Promise<RESTGetAPIChannelUsersThreadsArchivedResult>;
                    };
                };
            };
        };
        "voice-status": {
            put(
                args: RestArguments<{ status: null | string }>,
            ): Promise<undefined>;
        };
        webhooks: {
            get(
                args?: RestArgumentsNoBody,
            ): Promise<RESTGetAPIGuildWebhooksResult>;
            post(
                args: RestArguments<RESTPostAPIChannelWebhookJSONBody>,
            ): Promise<APIWebhook>;
        };
        delete(args?: RestArgumentsNoBody): Promise<APIChannel>;
        get(args?: RestArgumentsNoBody): Promise<APIChannel>;
        patch(
            args: RestArguments<RESTPatchAPIChannelJSONBody>,
        ): Promise<APIChannel>;
        polls(
            messageId: string,
        ): {
            expire: { post(args?: RestArgumentsNoBody): Promise<APIMessage> };
            answers(
                id: ValidAnswerId,
            ): {
                get(
                    args?: RestArgumentsNoBody<RESTGetAPIPollAnswerVotersQuery>,
                ): Promise<RESTGetAPIPollAnswerVotersResult>;
            };
        };
    };
    invites(
        id: string,
    ): {
        delete(args?: RestArgumentsNoBody): Promise<APIInvite>;
        get(args?: RestArguments<RESTGetAPIInviteQuery>): Promise<APIInvite>;
    };
    stickers(
        id: string,
    ): { get(args?: RestArgumentsNoBody): Promise<APISticker> };
    webhooks(
        id: string,
    ): {
        delete(args?: RestArgumentsNoBody): Promise<undefined>;
        get(args?: RestArgumentsNoBody): Promise<APIWebhook>;
        patch(
            args: RestArguments<RESTPatchAPIWebhookJSONBody>,
        ): Promise<APIWebhook>;
        (
            token: string,
        ): {
            github: {
                post(
                    args: RestArguments<
                        RESTPostAPIWebhookWithTokenJSONBody,
                        RESTPostAPIWebhookWithTokenGitHubQuery,
                    >,
                ): Promise<undefined | APIMessage>;
            };
            messages: (
                id: string,
            ) => {
                delete(args?: RestArgumentsNoBody): Promise<undefined>;
                get(
                    args?: RestArgumentsNoBody<{ thread_id: string }>,
                ): Promise<APIMessage>;
                patch(
                    args: RestArguments<RESTPatchAPIWebhookWithTokenMessageJSONBody>,
                ): Promise<APIMessage>;
            };
            slack: {
                post(
                    args: RestArguments<
                        RESTPostAPIWebhookWithTokenJSONBody,
                        RESTPostAPIWebhookWithTokenSlackQuery,
                    >,
                ): Promise<undefined | APIMessage>;
            };
            delete(args?: RestArgumentsNoBody): Promise<undefined>;
            get(
                args?: RestArgumentsNoBody,
            ): Promise<RESTGetAPIWebhookWithTokenResult>;
            patch(
                args: RestArguments<
                    RESTPatchAPIWebhookWithTokenJSONBody,
                    RESTPatchAPIWebhookWithTokenMessageQuery,
                >,
            ): Promise<RESTGetAPIWebhookWithTokenResult>;
            post(
                args: RestArguments<
                    RESTPostAPIWebhookWithTokenJSONBody,
                    RESTPostAPIWebhookWithTokenQuery,
                >,
            ): Promise<undefined | APIMessage>;
        };
    };
}