@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/discordbot/executors.js

@@ -1,10 +1,10 @@
-import { Buffer } from "node:buffer";
 import { optionalBoolean, optionalInteger, optionalRecord, optionalString, requiredString } from "../../core/cast.js";
-import { encodePathSegment, jsonObject } from "../../core/request.js";
-import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, } from "../provider-runtime.js";
+import { jsonObject } from "../../core/request.js";
+import { combineProviderActionHandlers, defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerResponseError, } from "../provider-runtime.js";
+import { guildActionHandlers } from "./runtime-guilds.js";
+import { discordProxyBaseUrl, discordbotRequest, discordbotRequestJson, discordbotRequestNoContent, requiredPath, } from "./runtime.js";
 const service = "discordbot";
-const discordApiBaseUrl = "https://discord.com/api";
-export const discordbotActionHandlers = {
+const coreActionHandlers = {
     test_auth(_input, context) {
         return testAuth(context);
     },
@@ -29,18 +29,6 @@ export const discordbotActionHandlers = {
     get_user(input, context) {
         return discordbotRequestJson({ path: `/users/${requiredPath(input.user_id, "user_id")}`, context });
     },
-    get_guild(input, context) {
-        return discordbotRequestJson({ path: `/guilds/${requiredPath(input.guild_id, "guild_id")}`, context });
-    },
-    list_guild_channels(input, context) {
-        return discordbotRequestJson({
-            path: `/guilds/${requiredPath(input.guild_id, "guild_id")}/channels`,
-            context,
-        }).then((channels) => ({ channels }));
-    },
-    list_guild_roles(input, context) {
-        return discordbotRequestJson({ path: `/guilds/${requiredPath(input.guild_id, "guild_id")}/roles`, context }).then((roles) => ({ roles }));
-    },
     get_channel(input, context) {
         return discordbotRequestJson({ path: `/channels/${requiredPath(input.channel_id, "channel_id")}`, context });
     },
@@ -77,22 +65,18 @@ export const discordbotActionHandlers = {
             context,
         }).then((message) => ({ message }));
     },
-    async delete_message(input, context) {
-        await discordbotRequest({
+    delete_message(input, context) {
+        return discordbotRequestNoContent({
             method: "DELETE",
             path: `/channels/${requiredPath(input.channel_id, "channel_id")}/messages/${requiredPath(input.message_id, "message_id")}`,
             context,
         });
-        return { success: true };
-    },
-    get_guild_widget_png(input, context) {
-        return getGuildWidgetPng(input, context);
     },
 };
-export const executors = defineApiKeyProviderExecutors(service, discordbotActionHandlers);
+export const executors = defineApiKeyProviderExecutors(service, combineProviderActionHandlers(service, coreActionHandlers, guildActionHandlers));
 export const proxy = defineProviderProxy({
     service,
-    baseUrl: discordApiBaseUrl,
+    baseUrl: discordProxyBaseUrl,
     auth: { type: "api_key_authorization", prefix: "Bot " },
 });
 export const credentialValidators = {
@@ -125,85 +109,9 @@ async function testAuth(context) {
         error_body: await response.text().catch(() => ""),
     };
 }
-async function getGuildWidgetPng(input, context) {
-    const guildId = requiredString(input.guild_id, "guild_id", providerInputError);
-    const response = await discordbotRequest({
-        path: `/guilds/${encodePathSegment(guildId)}/widget.png`,
-        query: jsonObject({ style: optionalString(input.style) }),
-        context,
-        authenticated: false,
-    });
-    const buffer = Buffer.from(await response.arrayBuffer());
-    return {
-        filename: `discord-guild-${guildId}-widget-${optionalString(input.style) ?? "shield"}.png`,
-        mimeType: response.headers.get("content-type") ?? "image/png",
-        sizeBytes: buffer.byteLength,
-        dataBase64: buffer.toString("base64"),
-    };
-}
-async function discordbotRequestJson(input) {
-    const response = await discordbotRequest(input);
-    try {
-        return (await response.json());
-    }
-    catch {
-        throw new ProviderRequestError(502, "Discord returned invalid JSON");
-    }
-}
-async function discordbotRequest(input) {
-    const url = new URL(`${discordApiBaseUrl}${input.path}`);
-    for (const [key, value] of Object.entries(input.query ?? {})) {
-        if (value !== undefined) {
-            url.searchParams.set(key, String(value));
-        }
-    }
-    const headers = new Headers();
-    if (input.authenticated !== false) {
-        headers.set("authorization", `Bot ${input.context.apiKey}`);
-    }
-    if (input.body !== undefined) {
-        headers.set("content-type", "application/json");
-    }
-    const response = await input.context.fetcher(url, {
-        method: input.method,
-        headers,
-        body: input.body === undefined ? undefined : JSON.stringify(input.body),
-        signal: input.context.signal,
-    });
-    if (!input.skipError && !response.ok) {
-        throw await toDiscordbotError(response, input.authenticated !== false);
-    }
-    return response;
-}
-async function toDiscordbotError(response, authenticated) {
-    const text = await response.text().catch(() => "");
-    let message = text;
-    if (text) {
-        try {
-            const parsed = JSON.parse(text);
-            message =
-                optionalString(parsed.message) ??
-                    optionalString(parsed.error_description) ??
-                    optionalString(parsed.error) ??
-                    text;
-        }
-        catch { }
-    }
-    const resolvedMessage = message || `Discord request failed with ${response.status}`;
-    if (authenticated && (response.status === 401 || response.status === 403)) {
-        return new ProviderRequestError(401, resolvedMessage);
-    }
-    if (response.status === 429) {
-        return new ProviderRequestError(429, resolvedMessage);
-    }
-    return new ProviderRequestError(response.status, resolvedMessage);
-}
 function assertSingleCursor(input) {
     const count = [input.around, input.before, input.after].filter((value) => optionalString(value)).length;
     if (count > 1) {
         throw new ProviderRequestError(400, "list_messages accepts only one of around, before, or after");
     }
 }
-function requiredPath(value, field) {
-    return encodePathSegment(requiredString(value, field, providerInputError));
-}

package/src/providers/discordbot/runtime-guilds.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderActionHandlerSubset } from "../provider-runtime.ts";
+import type { DiscordbotActionHandler } from "./runtime.ts";
+export declare const guildActionHandlers: ProviderActionHandlerSubset<"discordbot", DiscordbotActionHandler>;

package/src/providers/discordbot/runtime-guilds.js

@@ -0,0 +1,464 @@
+import { Buffer } from "node:buffer";
+import { booleanString, looseArray, nullableBoolean, nullableInteger, nullableRawString, nullableString, objectArray, optionalBoolean, optionalInteger, optionalRawString, optionalRecord, optionalString, optionalStringArray, recordOrEmpty, } from "../../core/cast.js";
+import { jsonObject } from "../../core/request.js";
+import { providerInputError, requiredInputString } from "../provider-runtime.js";
+import { discordbotRequest, discordbotRequestJson, discordbotRequestJsonOrNull, discordbotRequestNoContent, requiredPath, } from "./runtime.js";
+export const guildActionHandlers = {
+    get_guild(input, context) {
+        return discordbotRequestJson({
+            path: guildPath(input),
+            query: { with_counts: booleanString(input.with_counts) },
+            context,
+        });
+    },
+    get_guild_preview(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/preview`, context });
+    },
+    modify_guild(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: guildPath(input),
+            body: jsonObject({
+                name: optionalString(input.name),
+                verification_level: nullableInteger(input.verification_level),
+                default_message_notifications: nullableInteger(input.default_message_notifications),
+                explicit_content_filter: nullableInteger(input.explicit_content_filter),
+                afk_channel_id: nullableString(input.afk_channel_id),
+                afk_timeout: optionalInteger(input.afk_timeout),
+                icon: nullableString(input.icon),
+                splash: nullableString(input.splash),
+                discovery_splash: nullableString(input.discovery_splash),
+                banner: nullableString(input.banner),
+                system_channel_id: nullableString(input.system_channel_id),
+                system_channel_flags: optionalInteger(input.system_channel_flags),
+                rules_channel_id: nullableString(input.rules_channel_id),
+                public_updates_channel_id: nullableString(input.public_updates_channel_id),
+                safety_alerts_channel_id: nullableString(input.safety_alerts_channel_id),
+                preferred_locale: nullableString(input.preferred_locale),
+                features: optionalStringArray(input.features),
+                description: nullableRawString(input.description),
+                premium_progress_bar_enabled: optionalBoolean(input.premium_progress_bar_enabled),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    list_guild_channels(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/channels`, context }).then((channels) => ({ channels }));
+    },
+    create_guild_channel(input, context) {
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/channels`,
+            body: jsonObject({
+                name: requiredInputString(input.name, "name"),
+                type: optionalInteger(input.type),
+                topic: channelTopic(input),
+                bitrate: optionalInteger(input.bitrate),
+                user_limit: optionalInteger(input.user_limit),
+                rate_limit_per_user: optionalInteger(input.rate_limit_per_user),
+                position: optionalInteger(input.position),
+                permission_overwrites: Array.isArray(input.permission_overwrites) ? input.permission_overwrites : undefined,
+                parent_id: optionalString(input.parent_id),
+                nsfw: optionalBoolean(input.nsfw),
+                rtc_region: nullableString(input.rtc_region),
+                video_quality_mode: optionalInteger(input.video_quality_mode),
+                default_auto_archive_duration: optionalInteger(input.default_auto_archive_duration),
+                default_reaction_emoji: optionalRecord(input.default_reaction_emoji),
+                available_tags: Array.isArray(input.available_tags) ? input.available_tags : undefined,
+                default_sort_order: optionalInteger(input.default_sort_order),
+                default_forum_layout: optionalInteger(input.default_forum_layout),
+                default_thread_rate_limit_per_user: optionalInteger(input.default_thread_rate_limit_per_user),
+                flags: optionalInteger(input.flags),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((channel) => ({ channel }));
+    },
+    modify_guild_channel_positions(input, context) {
+        return discordbotRequestNoContent({
+            method: "PATCH",
+            path: `${guildPath(input)}/channels`,
+            body: requiredPositions(input.positions).map((position) => jsonObject({
+                id: requiredInputString(position.id, "positions[].id"),
+                position: nullableInteger(position.position),
+                lock_permissions: nullableBoolean(position.lock_permissions),
+                parent_id: nullableString(position.parent_id),
+                flags: nullableInteger(position.flags),
+            })),
+            context,
+        });
+    },
+    list_active_guild_threads(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/threads/active`, context }).then((value) => {
+            const response = recordOrEmpty(value);
+            return { threads: looseArray(response.threads), members: looseArray(response.members) };
+        });
+    },
+    get_guild_member(input, context) {
+        return discordbotRequestJson({ path: memberPath(input), context });
+    },
+    list_guild_members(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/members`,
+            query: { limit: optionalInteger(input.limit), after: optionalString(input.after) },
+            context,
+        }).then((members) => ({ members }));
+    },
+    search_guild_members(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/members/search`,
+            query: {
+                query: requiredInputString(input.query, "query"),
+                limit: optionalInteger(input.limit),
+            },
+            context,
+        }).then((members) => ({ members }));
+    },
+    add_guild_member(input, context) {
+        return addGuildMember(input, context);
+    },
+    modify_guild_member(input, context) {
+        return discordbotRequestJsonOrNull({
+            method: "PATCH",
+            path: memberPath(input),
+            body: jsonObject({
+                nick: nullableRawString(input.nick),
+                roles: input.roles === null ? null : optionalStringArray(input.roles),
+                mute: nullableBoolean(input.mute),
+                deaf: nullableBoolean(input.deaf),
+                channel_id: nullableString(input.channel_id),
+                communication_disabled_until: nullableString(input.communication_disabled_until),
+                flags: nullableInteger(input.flags),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((member) => ({ member }));
+    },
+    modify_current_member(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/members/@me`,
+            body: jsonObject({
+                nick: nullableRawString(input.nick),
+                avatar: nullableString(input.avatar),
+                banner: nullableString(input.banner),
+                bio: nullableRawString(input.bio),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    add_guild_member_role(input, context) {
+        return discordbotRequestNoContent({
+            method: "PUT",
+            path: `${memberPath(input)}/roles/${requiredPath(input.role_id, "role_id")}`,
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    remove_guild_member_role(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: `${memberPath(input)}/roles/${requiredPath(input.role_id, "role_id")}`,
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    remove_guild_member(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: memberPath(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    list_guild_bans(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/bans`,
+            query: {
+                limit: optionalInteger(input.limit),
+                before: optionalString(input.before),
+                after: optionalString(input.after),
+            },
+            context,
+        }).then((bans) => ({ bans }));
+    },
+    get_guild_ban(input, context) {
+        return discordbotRequestJson({ path: banPath(input), context });
+    },
+    create_guild_ban(input, context) {
+        return discordbotRequestNoContent({
+            method: "PUT",
+            path: banPath(input),
+            body: jsonObject({ delete_message_seconds: optionalInteger(input.delete_message_seconds) }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    remove_guild_ban(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: banPath(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    bulk_guild_ban(input, context) {
+        const userIds = optionalStringArray(input.user_ids);
+        if (!userIds || userIds.length === 0) {
+            throw providerInputError("user_ids must be a non-empty array of user ids");
+        }
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/bulk-ban`,
+            body: jsonObject({
+                user_ids: userIds,
+                delete_message_seconds: optionalInteger(input.delete_message_seconds),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((value) => {
+            const response = recordOrEmpty(value);
+            return { banned_users: looseArray(response.banned_users), failed_users: looseArray(response.failed_users) };
+        });
+    },
+    list_guild_roles(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/roles`, context }).then((roles) => ({ roles }));
+    },
+    get_guild_role(input, context) {
+        return discordbotRequestJson({ path: rolePath(input), context });
+    },
+    get_guild_role_member_counts(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/roles/member-counts`, context }).then((counts) => ({
+            member_counts: recordOrEmpty(counts),
+        }));
+    },
+    create_guild_role(input, context) {
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/roles`,
+            body: roleBody(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    modify_guild_role_positions(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/roles`,
+            body: requiredPositions(input.positions).map((position) => jsonObject({
+                id: requiredInputString(position.id, "positions[].id"),
+                position: nullableInteger(position.position),
+            })),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((roles) => ({ roles }));
+    },
+    modify_guild_role(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: rolePath(input),
+            body: roleBody(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    delete_guild_role(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: rolePath(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_prune_count(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/prune`,
+            query: {
+                days: optionalInteger(input.days),
+                include_roles: optionalStringArray(input.include_roles)?.join(","),
+            },
+            context,
+        });
+    },
+    begin_guild_prune(input, context) {
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/prune`,
+            body: jsonObject({
+                days: optionalInteger(input.days),
+                compute_prune_count: optionalBoolean(input.compute_prune_count),
+                include_roles: optionalStringArray(input.include_roles),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    list_guild_voice_regions(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/regions`, context }).then((regions) => ({ regions }));
+    },
+    list_guild_invites(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/invites`, context }).then((invites) => ({ invites }));
+    },
+    list_guild_integrations(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/integrations`, context }).then((integrations) => ({
+            integrations,
+        }));
+    },
+    delete_guild_integration(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: `${guildPath(input)}/integrations/${requiredPath(input.integration_id, "integration_id")}`,
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_widget_settings(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/widget`, context });
+    },
+    modify_guild_widget(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/widget`,
+            body: jsonObject({
+                enabled: optionalBoolean(input.enabled),
+                channel_id: nullableString(input.channel_id),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_widget(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/widget.json`, context });
+    },
+    get_guild_vanity_url(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/vanity-url`, context });
+    },
+    get_guild_widget_png(input, context) {
+        return getGuildWidgetPng(input, context);
+    },
+    get_guild_welcome_screen(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/welcome-screen`, context });
+    },
+    modify_guild_welcome_screen(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/welcome-screen`,
+            body: jsonObject({
+                enabled: nullableBoolean(input.enabled),
+                welcome_channels: input.welcome_channels === null
+                    ? null
+                    : Array.isArray(input.welcome_channels)
+                        ? input.welcome_channels
+                        : undefined,
+                description: nullableRawString(input.description),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_onboarding(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/onboarding`, context });
+    },
+    modify_guild_onboarding(input, context) {
+        return discordbotRequestJson({
+            method: "PUT",
+            path: `${guildPath(input)}/onboarding`,
+            body: jsonObject({
+                prompts: Array.isArray(input.prompts) ? input.prompts : undefined,
+                default_channel_ids: optionalStringArray(input.default_channel_ids),
+                enabled: optionalBoolean(input.enabled),
+                mode: optionalInteger(input.mode),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    modify_guild_incident_actions(input, context) {
+        return discordbotRequestJson({
+            method: "PUT",
+            path: `${guildPath(input)}/incident-actions`,
+            body: jsonObject({
+                invites_disabled_until: nullableString(input.invites_disabled_until),
+                dms_disabled_until: nullableString(input.dms_disabled_until),
+            }),
+            context,
+        });
+    },
+};
+async function addGuildMember(input, context) {
+    // Discord answers 204 with no body when the user is already in the guild.
+    const member = await discordbotRequestJsonOrNull({
+        method: "PUT",
+        path: memberPath(input),
+        body: jsonObject({
+            access_token: requiredInputString(input.access_token, "access_token"),
+            nick: optionalRawString(input.nick),
+            roles: optionalStringArray(input.roles),
+            mute: optionalBoolean(input.mute),
+            deaf: optionalBoolean(input.deaf),
+        }),
+        context,
+    });
+    return { already_member: member === null, member };
+}
+async function getGuildWidgetPng(input, context) {
+    const guildId = requiredInputString(input.guild_id, "guild_id");
+    const response = await discordbotRequest({
+        path: `${guildPath(input)}/widget.png`,
+        query: { style: optionalString(input.style) },
+        context,
+        authenticated: false,
+    });
+    const buffer = Buffer.from(await response.arrayBuffer());
+    return {
+        filename: `discord-guild-${guildId}-widget-${optionalString(input.style) ?? "shield"}.png`,
+        mimeType: response.headers.get("content-type") ?? "image/png",
+        sizeBytes: buffer.byteLength,
+        dataBase64: buffer.toString("base64"),
+    };
+}
+/**
+ * Discord allows 4096 characters in the topic of a forum (15) or media (16) channel
+ * and 1024 in every other channel type, including the default text channel.
+ */
+function channelTopic(input) {
+    const topic = optionalRawString(input.topic);
+    const type = optionalInteger(input.type);
+    if (topic !== undefined && type !== 15 && type !== 16 && [...topic].length > 1024) {
+        throw providerInputError("topic must be at most 1024 characters unless type is 15 (forum) or 16 (media)");
+    }
+    return topic;
+}
+function roleBody(input) {
+    return jsonObject({
+        name: optionalRawString(input.name),
+        permissions: optionalString(input.permissions),
+        color: optionalInteger(input.color),
+        colors: optionalRecord(input.colors),
+        hoist: optionalBoolean(input.hoist),
+        icon: nullableString(input.icon),
+        unicode_emoji: nullableString(input.unicode_emoji),
+        mentionable: optionalBoolean(input.mentionable),
+    });
+}
+function requiredPositions(value) {
+    const positions = objectArray(value, "positions", providerInputError);
+    if (positions.length === 0) {
+        throw providerInputError("positions must not be empty");
+    }
+    return positions;
+}
+function guildPath(input) {
+    return `/guilds/${requiredPath(input.guild_id, "guild_id")}`;
+}
+function memberPath(input) {
+    return `${guildPath(input)}/members/${requiredPath(input.user_id, "user_id")}`;
+}
+function banPath(input) {
+    return `${guildPath(input)}/bans/${requiredPath(input.user_id, "user_id")}`;
+}
+function rolePath(input) {
+    return `${guildPath(input)}/roles/${requiredPath(input.role_id, "role_id")}`;
+}

package/src/providers/discordbot/runtime.d.ts

@@ -0,0 +1,42 @@
+export declare const discordProxyBaseUrl = "https://discord.com/api";
+export interface DiscordbotContext {
+    apiKey: string;
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}
+export type DiscordbotActionHandler = (input: Record<string, unknown>, context: DiscordbotContext) => Promise<unknown>;
+interface DiscordbotRequestOptions {
+    method?: string;
+    path: string;
+    query?: Record<string, unknown>;
+    /** JSON body. Discord's position endpoints take a top-level array. */
+    body?: Record<string, unknown> | unknown[];
+    context: DiscordbotContext;
+    authenticated?: boolean;
+    skipError?: boolean;
+    /** Sent as `X-Audit-Log-Reason` on endpoints that record one. */
+    auditLogReason?: unknown;
+}
+/** Send a Discord request and parse the JSON response body. */
+export declare function discordbotRequestJson(input: DiscordbotRequestOptions): Promise<unknown>;
+/**
+ * Send a Discord request whose success may be 200 with a JSON body or 204 with none,
+ * returning null for the 204.
+ */
+export declare function discordbotRequestJsonOrNull(input: DiscordbotRequestOptions): Promise<unknown>;
+/** Send a Discord request that answers with 204 No Content. */
+export declare function discordbotRequestNoContent(input: DiscordbotRequestOptions): Promise<{
+    success: true;
+}>;
+/** Send a Discord request, mapping non-2xx responses to provider errors unless `skipError` is set. */
+export declare function discordbotRequest(input: DiscordbotRequestOptions): Promise<Response>;
+/**
+ * Read a required snowflake input for use as one URL path segment. Only digits are
+ * accepted, because percent-encoding cannot keep an arbitrary id inside one segment:
+ * URL parsing resolves `.` and `..` as dot segments, and Discord decodes `%2F` into a
+ * path separator before routing. Either would send the request, with the same method
+ * and bot token, to another endpoint: `role_id: ".."` turns a role DELETE into one on
+ * the guild itself, and `user_id: "U/roles/R"` on Add Guild Member grants role R.
+ */
+export declare function requiredPath(value: unknown, field: string): string;
+export {};