seyfert 1.5.0 → 2.0.0

package/lib/client/client.js

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../types");
 const common_1 = require("../common");
 const events_1 = require("../events");
-const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
 const memberUpdate_1 = require("../websocket/discord/events/memberUpdate");
 const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 const base_1 = require("./base");
-const oninteractioncreate_1 = require("./oninteractioncreate");
-const onmessagecreate_1 = require("./onmessagecreate");
 const collectors_1 = require("./collectors");
+const transformers_1 = require("./transformers");
 let parentPort;
 class Client extends base_1.BaseClient {
     __handleGuilds = new Set();
@@ -23,13 +21,6 @@ class Client extends base_1.BaseClient {
     events = new events_1.EventHandler(this);
     constructor(options) {
         super(options);
-        this.options = (0, common_1.MergeOptions)({
-            commands: {
-                argsParser: options?.commands?.argsParser ?? onmessagecreate_1.defaultArgsParser,
-                optionsParser: options?.commands?.optionsParser ??
-                    onmessagecreate_1.defaultOptionsParser,
-            },
-        }, this.options);
     }
     setServices({ gateway, ...rest }) {
         super.setServices(rest);
@@ -48,9 +39,6 @@ class Client extends base_1.BaseClient {
             }
             else if (typeof rest.handlers.events === 'function') {
                 this.events = new events_1.EventHandler(this);
-                this.events.setHandlers({
-                    callback: rest.handlers.events,
-                });
             }
             else {
                 this.events = rest.handlers.events;
@@ -58,7 +46,7 @@ class Client extends base_1.BaseClient {
         }
     }
     async loadEvents(dir) {
-        dir ??= await this.getRC().then((x) => x.events);
+        dir ??= await this.getRC().then(x => x.events);
         if (dir && this.events) {
             await this.events.load(dir);
             this.logger.info('EventHandler loaded');
@@ -89,7 +77,7 @@ class Client extends base_1.BaseClient {
     async start(options = {}, execute = true) {
         await super.start(options);
         await this.loadEvents(options.eventsDir);
-        const { token: tokenRC, intents: intentsRC, debug: debugRC, } = await this.getRC();
+        const { token: tokenRC, intents: intentsRC, debug: debugRC } = await this.getRC();
         const token = options?.token ?? tokenRC;
         const intents = options?.connection?.intents ?? intentsRC;
         if (!this.gateway) {
@@ -123,7 +111,10 @@ class Client extends base_1.BaseClient {
         }
     }
     async onPacket(shardId, packet) {
-        await this.events?.runEvent('RAW', this, packet, shardId);
+        Promise.allSettled([
+            this.events?.runEvent('RAW', this, packet, shardId, false),
+            this.collectors.run('RAW', packet, this),
+        ]); //ignore promise
         switch (packet.t) {
             //// Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
@@ -138,47 +129,54 @@ class Client extends base_1.BaseClient {
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
                 break;
+            case 'GUILD_DELETE':
             case 'GUILD_CREATE': {
                 if (this.__handleGuilds?.has(packet.d.id)) {
-                    this.__handleGuilds.delete(packet.d.id);
-                    if (!this.__handleGuilds.size &&
-                        [...this.gateway.values()].every((shard) => shard.data.session_id)) {
-                        await this.events?.runEvent('BOT_READY', this, this.me, -1);
+                    this.__handleGuilds?.delete(packet.d.id);
+                    if (!this.__handleGuilds?.size && [...this.gateway.values()].every(shard => shard.data.session_id)) {
+                        delete this.__handleGuilds;
+                        await this.cache.onPacket?.(packet);
+                        return this.events?.runEvent('BOT_READY', this, this.me, -1);
                     }
-                    if (!this.__handleGuilds.size)
+                    if (!this.__handleGuilds?.size)
                         delete this.__handleGuilds;
-                    return this.cache.onPacket(packet);
+                    return this.cache.onPacket?.(packet);
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
                 break;
             }
             //rest of the events
             default: {
-                await this.events?.execute(packet.t, packet, this, shardId);
                 switch (packet.t) {
                     case 'INTERACTION_CREATE':
-                        await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.interaction(packet.d, shardId);
                         break;
                     case 'MESSAGE_CREATE':
-                        await (0, onmessagecreate_1.onMessageCreate)(this, packet.d, shardId);
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.message(packet.d, shardId);
                         break;
                     case 'READY':
+                        if (!this.__handleGuilds)
+                            this.__handleGuilds = new Set();
                         for (const g of packet.d.guilds) {
                             this.__handleGuilds?.add(g.id);
                         }
                         this.botId = packet.d.user.id;
                         this.applicationId = packet.d.application.id;
-                        this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
+                        this.me = transformers_1.Transformers.ClientUser(this, packet.d.user, packet.d.application);
                         if (!(this.__handleGuilds?.size &&
-                            (this.gateway.options.intents &
-                                v10_1.GatewayIntentBits.Guilds) ===
-                                v10_1.GatewayIntentBits.Guilds)) {
-                            if ([...this.gateway.values()].every((shard) => shard.data.session_id)) {
+                            (this.gateway.options.intents & types_1.GatewayIntentBits.Guilds) === types_1.GatewayIntentBits.Guilds)) {
+                            if ([...this.gateway.values()].every(shard => shard.data.session_id)) {
                                 await this.events?.runEvent('BOT_READY', this, this.me, -1);
                             }
                             delete this.__handleGuilds;
                         }
                         this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        break;
+                    default:
+                        await this.events?.execute(packet.t, packet, this, shardId);
                         break;
                 }
                 break;

package/lib/client/collectors.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="node" />
 import type { Awaitable, CamelCase } from '../common';
 import type { CallbackEventHandler, CustomEventsKeys, GatewayEvents } from '../events';
 export type AllClientEvents = CustomEventsKeys | GatewayEvents;
 export type ParseClientEventName<T extends AllClientEvents> = T extends CustomEventsKeys ? T : CamelCase<T>;
+export type CollectorRunPameters<T extends AllClientEvents> = Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>;
 type RunData<T extends AllClientEvents> = {
     options: {
         event: T;
@@ -10,9 +10,9 @@ type RunData<T extends AllClientEvents> = {
         timeout?: number;
         onStop?: (reason: string) => unknown;
         onStopError?: (reason: string, error: unknown) => unknown;
-        filter: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>) => Awaitable<boolean>;
-        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string) => void) => unknown;
-        onRunError?: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string) => void) => unknown;
+        filter: (arg: CollectorRunPameters<T>) => Awaitable<boolean>;
+        run: (arg: CollectorRunPameters<T>, stop: (reason?: string) => void) => unknown;
+        onRunError?: (arg: CollectorRunPameters<T>, error: unknown, stop: (reason?: string) => void) => unknown;
     };
     idle?: NodeJS.Timeout;
     timeout?: NodeJS.Timeout;
@@ -23,13 +23,13 @@ export declare class Collectors {
     private generateRandomUUID;
     create<T extends AllClientEvents>(options: RunData<T>['options']): {
         event: T;
-        idle?: number | undefined;
-        timeout?: number | undefined;
-        onStop?: ((reason: string) => unknown) | undefined;
-        onStopError?: ((reason: string, error: unknown) => unknown) | undefined;
+        idle?: number;
+        timeout?: number;
+        onStop?: (reason: string) => unknown;
+        onStopError?: (reason: string, error: unknown) => unknown;
         filter: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>) => Awaitable<boolean>;
-        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string | undefined) => void) => unknown;
-        onRunError?: ((arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string | undefined) => void) => unknown) | undefined;
+        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string) => void) => unknown;
+        onRunError?: ((arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string) => void) => unknown) | undefined;
     };
     private delete;
 }

package/lib/client/collectors.js

@@ -1,8 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Collectors = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_console_1 = require("node:console");
+const RawEvents = __importStar(require("../events/hooks"));
 class Collectors {
     values = new Map();
     generateRandomUUID(name) {
@@ -61,10 +85,11 @@ class Collectors {
         }
     }
     /**@internal */
-    async run(name, data) {
+    async run(name, raw, client) {
         const collectors = this.values.get(name);
         if (!collectors)
             return;
+        const data = (await RawEvents[name]?.(client, raw)) ?? raw;
         for (const i of collectors) {
             if (await i.options.filter(data)) {
                 i.idle?.refresh();

package/lib/client/httpclient.d.ts

@@ -1,19 +1,14 @@
-/// <reference types="node" />
-import { type APIInteraction } from 'discord-api-types/v10';
-import type { HttpRequest, HttpResponse } from 'uWebSockets.js';
-import { type DeepPartial } from '../common';
+import type { APIInteractionResponse, APIInteraction } from '../types';
+import type { DeepPartial } from '../common';
 import type { BaseClientOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 export declare class HttpClient extends BaseClient {
-    app?: ReturnType<typeof import('uWebSockets.js').App>;
-    publicKey: string;
-    publicKeyHex: Buffer;
     constructor(options?: BaseClientOptions);
-    protected static readJson<T extends Record<string, any>>(res: HttpResponse): Promise<T>;
-    protected execute(options: DeepPartial<StartOptions['httpConnection']>): Promise<void>;
     start(options?: DeepPartial<Omit<StartOptions, 'connection' | 'eventsDir'>>): Promise<void>;
-    protected verifySignatureGenericRequest(req: Request): Promise<APIInteraction | undefined>;
-    protected verifySignature(res: HttpResponse, req: HttpRequest): Promise<APIInteraction | undefined>;
-    fetch(req: Request): Promise<Response>;
-    protected onPacket(res: HttpResponse, req: HttpRequest): Promise<void>;
+    onPacket(rawBody: APIInteraction): Promise<{
+        headers: {
+            'Content-Type'?: string;
+        };
+        response: APIInteractionResponse | FormData;
+    }>;
 }

package/lib/client/httpclient.js

@@ -1,237 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
-const v10_1 = require("discord-api-types/v10");
-const magic_bytes_js_1 = require("magic-bytes.js");
-const api_1 = require("../api");
 const utils_1 = require("../api/utils/utils");
-const common_1 = require("../common");
 const base_1 = require("./base");
-const oninteractioncreate_1 = require("./oninteractioncreate");
-let UWS;
-let nacl;
-try {
-    UWS = require('uWebSockets.js');
-}
-catch {
-    // easter egg #1
-}
-try {
-    nacl = require('tweetnacl');
-}
-catch {
-    // I always cum
-}
 class HttpClient extends base_1.BaseClient {
-    app;
-    publicKey;
-    publicKeyHex;
     constructor(options) {
         super(options);
-        // if (!UWS) {
-        // 	throw new Error('No uws installed.');
-        // }
-        if (!nacl) {
-            throw new Error('No tweetnacl installed.');
-        }
     }
-    static readJson(res) {
-        return new Promise((cb, err) => {
-            let buffer;
-            res.onData((ab, isLast) => {
-                const chunk = Buffer.from(ab);
-                if (isLast) {
-                    let json;
-                    try {
-                        json = JSON.parse(buffer ? Buffer.concat([buffer, chunk]).toString() : chunk.toString());
+    async start(options = {}) {
+        await super.start(options);
+        return this.execute(options.httpConnection ?? {});
+    }
+    async onPacket(rawBody) {
+        return new Promise(async (r) => {
+            await this.handleCommand.interaction(rawBody, -1, async ({ body, files }) => {
+                let response;
+                const headers = {};
+                if (files) {
+                    response = new FormData();
+                    for (const [index, file] of files.entries()) {
+                        const fileKey = file.key ?? `files[${index}]`;
+                        if ((0, utils_1.isBufferLike)(file.data)) {
+                            response.append(fileKey, new Blob([file.data], { type: file.contentType }), file.name);
+                        }
+                        else {
+                            response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
+                        }
                     }
-                    catch (e) {
-                        res.close();
-                        return;
+                    if (body) {
+                        response.append('payload_json', JSON.stringify(body));
                     }
-                    cb(json);
                 }
                 else {
-                    buffer = Buffer.concat(buffer ? [buffer, chunk] : [chunk]);
+                    response = body ?? {};
+                    headers['Content-Type'] = 'application/json';
                 }
+                return r({
+                    headers,
+                    response,
+                });
             });
-            res.onAborted(err);
         });
     }
-    async execute(options) {
-        await super.execute();
-        const { publicKey: publicKeyRC, port: portRC, applicationId: applicationIdRC, } = await this.getRC();
-        const publicKey = options.publicKey ?? publicKeyRC;
-        const port = options.port ?? portRC;
-        if (!publicKey) {
-            throw new Error('Expected a publicKey, check your config file');
-        }
-        if (!port) {
-            throw new Error('Expected a port, check your config file');
-        }
-        if (applicationIdRC) {
-            this.applicationId = applicationIdRC;
-        }
-        this.publicKey = publicKey;
-        this.publicKeyHex = Buffer.from(this.publicKey, 'hex');
-        if (UWS && options.useUWS) {
-            this.app = UWS.App();
-            this.app.post('/interactions', (res, req) => {
-                return this.onPacket(res, req);
-            });
-            this.app.listen(port, () => {
-                this.logger.info(`Listening to <url>:${port}/interactions`);
-            });
-        }
-        else {
-            if (options.useUWS)
-                return this.logger.warn('No uWebSockets installed.');
-            this.logger.info('Use your preferred http server and invoke <HttpClient>.fetch(<Request>) to get started');
-        }
-    }
-    async start(options = {}) {
-        await super.start(options);
-        return this.execute((0, common_1.MergeOptions)({ useUWS: true }, options.httpConnection));
-    }
-    async verifySignatureGenericRequest(req) {
-        const timestamp = req.headers.get('x-signature-timestamp');
-        const ed25519 = req.headers.get('x-signature-ed25519') ?? '';
-        const body = (await req.json());
-        if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
-            return body;
-        }
-        return;
-    }
-    // https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
-    async verifySignature(res, req) {
-        const timestamp = req.getHeader('x-signature-timestamp');
-        const ed25519 = req.getHeader('x-signature-ed25519');
-        const body = await HttpClient.readJson(res);
-        if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
-            return body;
-        }
-        return;
-    }
-    async fetch(req) {
-        const rawBody = await this.verifySignatureGenericRequest(req);
-        if (!rawBody) {
-            this.debugger?.debug('Invalid request/No info, returning 418 status.');
-            // I'm a teapot
-            return new Response('', { status: 418 });
-        }
-        switch (rawBody.type) {
-            case v10_1.InteractionType.Ping:
-                this.debugger?.debug('Ping interaction received, responding.');
-                return Response.json({ type: v10_1.InteractionResponseType.Pong }, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                });
-            default:
-                return new Promise(r => {
-                    if ((0, common_1.isCloudfareWorker)())
-                        return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1)
-                            .then(() => r(new Response()))
-                            .catch(() => r(new Response()));
-                    return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1, async ({ body, files }) => {
-                        let response;
-                        const headers = {};
-                        if (files) {
-                            response = new FormData();
-                            for (const [index, file] of files.entries()) {
-                                const fileKey = file.key ?? `files[${index}]`;
-                                if ((0, utils_1.isBufferLike)(file.data)) {
-                                    let contentType = file.contentType;
-                                    if (!contentType) {
-                                        const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
-                                        if (parsedType) {
-                                            contentType =
-                                                api_1.OverwrittenMimeTypes[parsedType.mime] ??
-                                                    parsedType.mime ??
-                                                    'application/octet-stream';
-                                        }
-                                    }
-                                    response.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
-                                }
-                                else {
-                                    response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
-                                }
-                            }
-                            if (body) {
-                                response.append('payload_json', JSON.stringify(body));
-                            }
-                        }
-                        else {
-                            response = body ?? {};
-                            headers['Content-Type'] = 'application/json';
-                        }
-                        r(response instanceof FormData
-                            ? new Response(response, { headers })
-                            : Response.json(response, {
-                                headers,
-                            }));
-                    });
-                });
-        }
-    }
-    async onPacket(res, req) {
-        const rawBody = await this.verifySignature(res, req);
-        if (rawBody) {
-            switch (rawBody.type) {
-                case v10_1.InteractionType.Ping:
-                    this.debugger?.debug('Ping interaction received, responding.');
-                    res
-                        .writeHeader('Content-Type', 'application/json')
-                        .end(JSON.stringify({ type: v10_1.InteractionResponseType.Pong }));
-                    break;
-                default:
-                    await (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1, async ({ body, files }) => {
-                        res.cork(() => {
-                            let response;
-                            const headers = {};
-                            if (files) {
-                                response = new FormData();
-                                for (const [index, file] of files.entries()) {
-                                    const fileKey = file.key ?? `files[${index}]`;
-                                    if ((0, utils_1.isBufferLike)(file.data)) {
-                                        let contentType = file.contentType;
-                                        if (!contentType) {
-                                            const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
-                                            if (parsedType) {
-                                                contentType =
-                                                    api_1.OverwrittenMimeTypes[parsedType.mime] ??
-                                                        parsedType.mime ??
-                                                        'application/octet-stream';
-                                            }
-                                        }
-                                        response.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
-                                    }
-                                    else {
-                                        response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
-                                    }
-                                }
-                                if (body) {
-                                    response.append('payload_json', JSON.stringify(body));
-                                }
-                            }
-                            else {
-                                response = body ?? {};
-                                headers['Content-Type'] = 'application/json';
-                            }
-                            for (const i in headers) {
-                                res.writeHeader(i, headers[i]);
-                            }
-                            return res.end(JSON.stringify(response));
-                        });
-                    });
-                    break;
-            }
-        }
-        else {
-            this.debugger?.debug('Invalid request/No info, returning 418 status.');
-            // I'm a teapot
-            res.writeStatus('418').end();
-        }
-    }
 }
 exports.HttpClient = HttpClient;

package/lib/client/index.d.ts

@@ -2,3 +2,4 @@ export type { RuntimeConfig, RuntimeConfigHTTP } from './base';
 export * from './client';
 export * from './httpclient';
 export * from './workerclient';
+export * from './transformers';

package/lib/client/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client"), exports);
 __exportStar(require("./httpclient"), exports);
 __exportStar(require("./workerclient"), exports);
+__exportStar(require("./transformers"), exports);

package/lib/client/transformers.d.ts

@@ -0,0 +1,68 @@
+import type { ChannelType } from '../types';
+import { type CustomStructures, OptionResolver } from '../commands';
+import { AnonymousGuild, AutoModerationRule, BaseChannel, BaseGuildChannel, CategoryChannel, ClientUser, DMChannel, DirectoryChannel, ForumChannel, Guild, GuildEmoji, GuildMember, GuildRole, GuildTemplate, InteractionGuildMember, MediaChannel, Message, NewsChannel, Poll, StageChannel, Sticker, TextGuildChannel, ThreadChannel, User, VoiceChannel, VoiceState, Webhook, WebhookMessage } from '../structures';
+import type { StructStates } from '../common/';
+import { GuildBan } from '../structures/GuildBan';
+export type PollStructure = InferCustomStructure<Poll, 'Poll'>;
+export type ClientUserStructure = InferCustomStructure<ClientUser, 'ClientUser'>;
+export type AnonymousGuildStructure = InferCustomStructure<AnonymousGuild, 'AnonymousGuild'>;
+export type AutoModerationRuleStructure = InferCustomStructure<AutoModerationRule, 'AutoModerationRule'>;
+export type BaseChannelStructure = InferCustomStructure<BaseChannel<ChannelType>, 'BaseChannel'>;
+export type BaseGuildChannelStructure = InferCustomStructure<BaseGuildChannel, 'BaseGuildChannel'>;
+export type TextGuildChannelStructure = InferCustomStructure<TextGuildChannel, 'TextGuildChannel'>;
+export type DMChannelStructure = InferCustomStructure<DMChannel, 'DMChannel'>;
+export type VoiceChannelStructure = InferCustomStructure<VoiceChannel, 'VoiceChannel'>;
+export type StageChannelStructure = InferCustomStructure<StageChannel, 'StageChannel'>;
+export type MediaChannelStructure = InferCustomStructure<MediaChannel, 'MediaChannel'>;
+export type ForumChannelStructure = InferCustomStructure<ForumChannel, 'ForumChannel'>;
+export type ThreadChannelStructure = InferCustomStructure<ThreadChannel, 'ThreadChannel'>;
+export type CategoryChannelStructure = InferCustomStructure<CategoryChannel, 'CategoryChannel'>;
+export type NewsChannelStructure = InferCustomStructure<NewsChannel, 'NewsChannel'>;
+export type DirectoryChannelStructure = InferCustomStructure<DirectoryChannel, 'DirectoryChannel'>;
+export type GuildStructure<State extends StructStates = 'api'> = InferCustomStructure<Guild<State>, 'Guild'>;
+export type GuildBanStructure = InferCustomStructure<GuildBan, 'GuildBan'>;
+export type GuildEmojiStructure = InferCustomStructure<GuildEmoji, 'GuildEmoji'>;
+export type GuildMemberStructure = InferCustomStructure<GuildMember, 'GuildMember'>;
+export type InteractionGuildMemberStructure = InferCustomStructure<InteractionGuildMember, 'InteractionGuildMember'>;
+export type GuildRoleStructure = InferCustomStructure<GuildRole, 'GuildRole'>;
+export type GuildTemplateStructure = InferCustomStructure<GuildTemplate, 'GuildTemplate'>;
+export type MessageStructure = InferCustomStructure<Message, 'Message'>;
+export type WebhookMessageStructure = InferCustomStructure<WebhookMessage, 'WebhookMessage'>;
+export type StickerStructure = InferCustomStructure<Sticker, 'Sticker'>;
+export type UserStructure = InferCustomStructure<User, 'User'>;
+export type VoiceStateStructure = InferCustomStructure<VoiceState, 'VoiceState'>;
+export type WebhookStructure = InferCustomStructure<Webhook, 'Webhook'>;
+export type OptionResolverStructure = InferCustomStructure<OptionResolver, 'OptionResolver'>;
+export declare class Transformers {
+    static AnonymousGuild(...args: ConstructorParameters<typeof AnonymousGuild>): AnonymousGuildStructure;
+    static AutoModerationRule(...args: ConstructorParameters<typeof AutoModerationRule>): AutoModerationRuleStructure;
+    static BaseChannel(...args: ConstructorParameters<typeof BaseChannel>): BaseChannelStructure;
+    static BaseGuildChannel(...args: ConstructorParameters<typeof BaseGuildChannel>): BaseGuildChannelStructure;
+    static TextGuildChannel(...args: ConstructorParameters<typeof TextGuildChannel>): TextGuildChannelStructure;
+    static DMChannel(...args: ConstructorParameters<typeof DMChannel>): DMChannelStructure;
+    static VoiceChannel(...args: ConstructorParameters<typeof VoiceChannel>): VoiceChannelStructure;
+    static StageChannel(...args: ConstructorParameters<typeof StageChannel>): StageChannelStructure;
+    static MediaChannel(...args: ConstructorParameters<typeof MediaChannel>): MediaChannelStructure;
+    static ForumChannel(...args: ConstructorParameters<typeof ForumChannel>): ForumChannelStructure;
+    static ThreadChannel(...args: ConstructorParameters<typeof ThreadChannel>): ThreadChannelStructure;
+    static CategoryChannel(...args: ConstructorParameters<typeof CategoryChannel>): CategoryChannelStructure;
+    static NewsChannel(...args: ConstructorParameters<typeof NewsChannel>): NewsChannelStructure;
+    static DirectoryChannel(...args: ConstructorParameters<typeof DirectoryChannel>): DirectoryChannelStructure;
+    static ClientUser(...args: ConstructorParameters<typeof ClientUser>): ClientUserStructure;
+    static Guild<State extends StructStates = 'api'>(...args: ConstructorParameters<typeof Guild>): GuildStructure<State>;
+    static GuildBan(...args: ConstructorParameters<typeof GuildBan>): GuildBanStructure;
+    static GuildEmoji(...args: ConstructorParameters<typeof GuildEmoji>): GuildEmojiStructure;
+    static GuildMember(...args: ConstructorParameters<typeof GuildMember>): GuildMemberStructure;
+    static InteractionGuildMember(...args: ConstructorParameters<typeof InteractionGuildMember>): InteractionGuildMemberStructure;
+    static GuildRole(...args: ConstructorParameters<typeof GuildRole>): GuildRoleStructure;
+    static GuildTemplate(...args: ConstructorParameters<typeof GuildTemplate>): GuildTemplateStructure;
+    static Message(...args: ConstructorParameters<typeof Message>): MessageStructure;
+    static WebhookMessage(...args: ConstructorParameters<typeof WebhookMessage>): WebhookMessageStructure;
+    static Poll(...args: ConstructorParameters<typeof Poll>): PollStructure;
+    static Sticker(...args: ConstructorParameters<typeof Sticker>): StickerStructure;
+    static User(...args: ConstructorParameters<typeof User>): UserStructure;
+    static VoiceState(...args: ConstructorParameters<typeof VoiceState>): VoiceStateStructure;
+    static Webhook(...args: ConstructorParameters<typeof Webhook>): WebhookStructure;
+    static OptionResolver(...args: ConstructorParameters<typeof OptionResolver>): OptionResolverStructure;
+}
+export type InferCustomStructure<T, N extends string> = CustomStructures extends Record<N, infer P> ? P : T;