seyfert 0.1.0

package/lib/common/shorters/messages.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageShorter = void 0;
+const builders_1 = require("../../builders");
+const structures_1 = require("../../structures");
+const functions_1 = require("../../structures/extra/functions");
+const base_1 = require("./base");
+class MessageShorter extends base_1.BaseShorter {
+    get messages() {
+        return {
+            write: async (channelId, { files, ...body }) => {
+                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages.post({
+                    body: transformedBody,
+                    files: parsedFiles,
+                })
+                    .then(message => {
+                    this.client.components.onRequestMessage(body, message);
+                    return new structures_1.Message(this.client, message);
+                });
+            },
+            edit: async (messageId, channelId, { files, ...body }) => {
+                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages(messageId)
+                    .patch({
+                    body: structures_1.MessagesMethods.transformMessageBody(body),
+                    files: parsedFiles,
+                })
+                    .then(message => {
+                    this.client.components.onRequestUpdateMessage(body, message);
+                    return new structures_1.Message(this.client, message);
+                });
+            },
+            crosspost: (messageId, channelId, reason) => {
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages(messageId)
+                    .crosspost.post({ reason })
+                    .then(m => new structures_1.Message(this.client, m));
+            },
+            delete: (messageId, channelId, reason) => {
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages(messageId)
+                    .delete({ reason })
+                    .then(() => {
+                    return this.client.components.onMessageDelete(messageId);
+                });
+            },
+            fetch: async (messageId, channelId) => {
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages(messageId)
+                    .get()
+                    .then(x => new structures_1.Message(this.client, x));
+            },
+            purge: (messages, channelId, reason) => {
+                return this.client.proxy.channels(channelId).messages['bulk-delete'].post({ body: { messages }, reason });
+            },
+            reactions: this.reactions,
+        };
+    }
+    get reactions() {
+        return {
+            add: async (messageId, channelId, emoji) => {
+                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+                if (!rawEmoji) {
+                    throw new Error('Emoji no resolvable');
+                }
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages(messageId)
+                    .reactions((0, functions_1.encodeEmoji)(rawEmoji))('@me')
+                    .put({});
+            },
+            delete: async (messageId, channelId, emoji, userId = '@me') => {
+                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+                if (!rawEmoji) {
+                    throw new Error('Emoji no resolvable');
+                }
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages(messageId)
+                    .reactions((0, functions_1.encodeEmoji)(rawEmoji))(userId)
+                    .delete();
+            },
+            fetch: async (messageId, channelId, emoji, query) => {
+                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+                if (!rawEmoji) {
+                    throw new Error('Emoji no resolvable');
+                }
+                return this.client.proxy
+                    .channels(channelId)
+                    .messages(messageId)
+                    .reactions((0, functions_1.encodeEmoji)(rawEmoji))
+                    .get({ query })
+                    .then(u => u.map(user => new structures_1.User(this.client, user)));
+            },
+            purge: async (messageId, channelId, emoji) => {
+                if (!emoji) {
+                    return this.client.proxy.channels(channelId).messages(messageId).reactions.delete();
+                }
+                const rawEmoji = await (0, functions_1.resolveEmoji)(emoji, this.client.cache);
+                if (!rawEmoji) {
+                    throw new Error('Emoji no resolvable');
+                }
+                return this.client.proxy.channels(channelId).messages(messageId).reactions((0, functions_1.encodeEmoji)(rawEmoji)).delete();
+            },
+        };
+    }
+}
+exports.MessageShorter = MessageShorter;

package/lib/common/shorters/roles.d.ts

@@ -0,0 +1,12 @@
+import type { RESTPatchAPIGuildRoleJSONBody, RESTPatchAPIGuildRolePositionsJSONBody, RESTPostAPIGuildRoleJSONBody } from 'discord-api-types/v10';
+import { GuildRole } from '../../structures';
+import { BaseShorter } from './base';
+export declare class RoleShorter extends BaseShorter {
+    get roles(): {
+        create: (guildId: string, body: RESTPostAPIGuildRoleJSONBody, reason?: string) => Promise<any>;
+        list: (guildId: string, force?: boolean) => Promise<GuildRole[]>;
+        edit: (guildId: string, roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<any>;
+        delete: (guildId: string, roleId: string, reason?: string) => Promise<void | undefined>;
+        editPositions: (guildId: string, body: RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
+    };
+}

package/lib/common/shorters/roles.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleShorter = void 0;
+const structures_1 = require("../../structures");
+const base_1 = require("./base");
+class RoleShorter extends base_1.BaseShorter {
+    get roles() {
+        return {
+            create: (guildId, body, reason) => this.client.proxy
+                .guilds(guildId)
+                .roles.post({ body, reason })
+                .then(res => this.client.cache.roles?.setIfNI('Guilds', res.id, guildId, res)),
+            list: async (guildId, force = false) => {
+                let roles = [];
+                if (!force) {
+                    roles = (await this.client.cache.roles?.values(guildId)) ?? [];
+                    if (roles.length) {
+                        return roles.map(r => new structures_1.GuildRole(this.client, r, guildId));
+                    }
+                }
+                roles = await this.client.proxy.guilds(guildId).roles.get();
+                await this.client.cache.roles?.set(roles.map(r => [r.id, r]), guildId);
+                return roles.map(r => new structures_1.GuildRole(this.client, r, guildId));
+            },
+            edit: (guildId, roleId, body, reason) => {
+                return this.client.proxy
+                    .guilds(guildId)
+                    .roles(roleId)
+                    .patch({ body, reason })
+                    .then(res => this.client.cache.roles?.setIfNI('Guilds', roleId, guildId, res));
+            },
+            delete: (guildId, roleId, reason) => {
+                return this.client.proxy
+                    .guilds(guildId)
+                    .roles(roleId)
+                    .delete({ reason })
+                    .then(() => this.client.cache.roles?.removeIfNI('Guilds', roleId, guildId));
+            },
+            editPositions: async (guildId, body) => {
+                const roles = await this.client.proxy.guilds(guildId).roles.patch({
+                    body,
+                });
+                if (!this.client.cache.hasRolesIntent) {
+                    await this.client.cache.roles?.set(roles.map(x => [x.id, x]), guildId);
+                }
+                return roles.map(x => new structures_1.GuildRole(this.client, x, guildId));
+            },
+        };
+    }
+}
+exports.RoleShorter = RoleShorter;

package/lib/common/shorters/templates.d.ts

@@ -0,0 +1,12 @@
+import type { RESTPatchAPIGuildTemplateJSONBody, RESTPostAPIGuildTemplatesJSONBody } from 'discord-api-types/v10';
+import { BaseShorter } from './base';
+export declare class TemplateShorter extends BaseShorter {
+    get templates(): {
+        fetch: (code: string) => Promise<import("discord-api-types/v10").APITemplate>;
+        list: (guildId: string) => Promise<import("discord-api-types/v10").RESTGetAPIGuildTemplatesResult>;
+        create: (guildId: string, body: RESTPostAPIGuildTemplatesJSONBody) => Promise<import("discord-api-types/v10").APITemplate>;
+        sync: (guildId: string, code: string) => Promise<import("discord-api-types/v10").APITemplate>;
+        edit: (guildId: string, code: string, body: RESTPatchAPIGuildTemplateJSONBody) => Promise<import("discord-api-types/v10").APITemplate>;
+        delete: (guildId: string, code: string) => Promise<import("discord-api-types/v10").APITemplate>;
+    };
+}

package/lib/common/shorters/templates.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateShorter = void 0;
+const base_1 = require("./base");
+class TemplateShorter extends base_1.BaseShorter {
+    get templates() {
+        return {
+            fetch: (code) => {
+                return this.client.proxy.guilds.templates(code).get();
+            },
+            list: (guildId) => {
+                return this.client.proxy.guilds(guildId).templates.get();
+            },
+            create: (guildId, body) => {
+                return this.client.proxy.guilds(guildId).templates.post({ body });
+            },
+            sync: (guildId, code) => {
+                return this.client.proxy.guilds(guildId).templates(code).put({});
+            },
+            edit: (guildId, code, body) => {
+                return this.client.proxy.guilds(guildId).templates(code).patch({ body });
+            },
+            delete: (guildId, code) => {
+                return this.client.proxy.guilds(guildId).templates(code).delete();
+            },
+        };
+    }
+}
+exports.TemplateShorter = TemplateShorter;

package/lib/common/shorters/users.d.ts

@@ -0,0 +1,11 @@
+import { DMChannel, User } from '../../structures';
+import type { MessageCreateBodyRequest } from '../types/write';
+import { BaseShorter } from './base';
+export declare class UsersShorter extends BaseShorter {
+    get users(): {
+        createDM: (userId: string, force?: boolean) => Promise<DMChannel>;
+        deleteDM: (userId: string, reason?: string) => Promise<DMChannel>;
+        fetch: (userId: string, force?: boolean) => Promise<User>;
+        write: (userId: string, body: MessageCreateBodyRequest) => Promise<import("../../structures").Message>;
+    };
+}

package/lib/common/shorters/users.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersShorter = void 0;
+const structures_1 = require("../../structures");
+const base_1 = require("./base");
+class UsersShorter extends base_1.BaseShorter {
+    get users() {
+        return {
+            createDM: async (userId, force = false) => {
+                if (!force) {
+                    const dm = await this.client.cache.channels?.get(userId);
+                    if (dm)
+                        return dm;
+                }
+                const data = await this.client.proxy.users('@me').channels.post({
+                    body: { recipient_id: userId },
+                });
+                await this.client.cache.channels?.set(userId, '@me', data);
+                return new structures_1.DMChannel(this.client, data);
+            },
+            deleteDM: async (userId, reason) => {
+                const res = await this.client.proxy.channels(userId).delete({ reason });
+                await this.client.cache.channels?.removeIfNI(structures_1.BaseChannel.__intent__('@me'), res.id, '@me');
+                return new structures_1.DMChannel(this.client, res);
+            },
+            fetch: async (userId, force = false) => {
+                if (!force) {
+                    const user = await this.client.cache.users?.get(userId);
+                    if (user)
+                        return user;
+                }
+                const data = await this.client.proxy.users(userId).get();
+                await this.client.cache.users?.patch(userId, data);
+                return new structures_1.User(this.client, data);
+            },
+            write: async (userId, body) => {
+                return (await this.client.users.createDM(userId)).messages.write(body);
+            },
+        };
+    }
+}
+exports.UsersShorter = UsersShorter;

package/lib/common/shorters/webhook.d.ts

@@ -0,0 +1,33 @@
+import type { RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookWithTokenJSONBody, RESTPostAPIWebhookWithTokenJSONBody } from '..';
+import { type MessageWebhookMethodEditParams, type MessageWebhookMethodWriteParams, Webhook, WebhookMessage } from '../../structures';
+import { BaseShorter } from './base';
+export declare class WebhookShorter extends BaseShorter {
+    get webhooks(): {
+        delete: (webhookId: string, { token, reason }: WebhookShorterOptionalParams) => Promise<never>;
+        edit: (webhookId: string, body: RESTPatchAPIWebhookWithTokenJSONBody | RESTPatchAPIWebhookJSONBody, { token, reason }: WebhookShorterOptionalParams) => Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
+        fetch: (webhookId: string, token?: string) => Promise<Webhook>;
+        messages: {
+            write: (webhookId: string, token: string, { body: data, ...payload }: {
+                body: Omit<RESTPostAPIWebhookWithTokenJSONBody, "embeds" | "components"> & import("..").ResolverProps;
+                query?: import("discord-api-types/rest/v10/webhook").RESTPostAPIWebhookWithTokenQuery | undefined;
+            }) => Promise<WebhookMessage | null>;
+            edit: (webhookId: string, token: string, { messageId, body: data, ...json }: {
+                body: Omit<import("discord-api-types/rest/v10/webhook").RESTPatchAPIWebhookWithTokenMessageJSONBody, "embeds" | "components"> & import("..").ResolverProps;
+                messageId: string;
+                query?: import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenMessageQuery | undefined;
+            }) => Promise<WebhookMessage>;
+            delete: (webhookId: string, token: string, messageId: string, reason?: string | undefined) => Promise<never>;
+            fetch: (webhookId: string, token: string, messageId: string, threadId?: string | undefined) => Promise<WebhookMessage | undefined>;
+        };
+    };
+    get messages(): {
+        write: (webhookId: string, token: string, { body: data, ...payload }: MessageWebhookMethodWriteParams) => Promise<WebhookMessage | null>;
+        edit: (webhookId: string, token: string, { messageId, body: data, ...json }: MessageWebhookMethodEditParams) => Promise<WebhookMessage>;
+        delete: (webhookId: string, token: string, messageId: string, reason?: string) => Promise<never>;
+        fetch: (webhookId: string, token: string, messageId: string, threadId?: string) => Promise<WebhookMessage | undefined>;
+    };
+}
+export type WebhookShorterOptionalParams = Partial<{
+    token: string;
+    reason: string;
+}>;

package/lib/common/shorters/webhook.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookShorter = void 0;
+const builders_1 = require("../../builders");
+const structures_1 = require("../../structures");
+const base_1 = require("./base");
+class WebhookShorter extends base_1.BaseShorter {
+    get webhooks() {
+        return {
+            delete: (webhookId, { token, reason }) => {
+                if (token) {
+                    return this.client.proxy.webhooks(webhookId)(token).delete({ reason, auth: false });
+                }
+                return this.client.proxy.webhooks(webhookId).delete({ reason });
+            },
+            edit: (webhookId, body, { token, reason }) => {
+                if (token) {
+                    return this.client.proxy.webhooks(webhookId)(token).patch({ body, reason, auth: false });
+                }
+                return this.client.proxy.webhooks(webhookId).patch({ body, reason });
+            },
+            fetch: async (webhookId, token) => {
+                let webhook;
+                if (token) {
+                    webhook = await this.client.proxy.webhooks(webhookId)(token).get({ auth: false });
+                }
+                else {
+                    webhook = await this.client.proxy.webhooks(webhookId).get();
+                }
+                return new structures_1.Webhook(this.client, webhook);
+            },
+            messages: this.messages,
+        };
+    }
+    get messages() {
+        return {
+            write: async (webhookId, token, { body: data, ...payload }) => {
+                const { files, ...body } = data;
+                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+                return this.client.proxy
+                    .webhooks(webhookId)(token)
+                    .post({ ...payload, files: parsedFiles, body: transformedBody })
+                    .then(m => (m?.id ? new structures_1.WebhookMessage(this.client, m, webhookId, token) : null));
+            },
+            edit: async (webhookId, token, { messageId, body: data, ...json }) => {
+                const { files, ...body } = data;
+                const transformedBody = structures_1.MessagesMethods.transformMessageBody(body);
+                const parsedFiles = files ? await (0, builders_1.resolveFiles)(files) : [];
+                return this.client.proxy
+                    .webhooks(webhookId)(token)
+                    .messages(messageId)
+                    .patch({ ...json, auth: false, files: parsedFiles, body: transformedBody })
+                    .then(m => new structures_1.WebhookMessage(this.client, m, webhookId, token));
+            },
+            delete: async (webhookId, token, messageId, reason) => {
+                return this.client.proxy.webhooks(webhookId)(token).messages(messageId).delete({ reason });
+            },
+            fetch: async (webhookId, token, messageId, threadId) => {
+                const message = await this.client.proxy
+                    .webhooks(webhookId)(token)
+                    .messages(messageId)
+                    .get({ auth: false, query: { threadId } });
+                return message ? new structures_1.WebhookMessage(this.client, message, webhookId, token) : undefined;
+            },
+        };
+    }
+}
+exports.WebhookShorter = WebhookShorter;

package/lib/common/types/options.d.ts

@@ -0,0 +1,10 @@
+import type { Identify } from '..';
+import type { ImageURLOptions } from '../../api';
+import type { BaseClient } from '../../client/base';
+export type ImageOptions = ImageURLOptions;
+export type MethodContext<T = {}> = Identify<{
+    client: BaseClient;
+} & T>;
+export type MessageWebhookPayload<Body, Extra = {}> = Identify<{
+    body: Body;
+} & Extra>;

package/lib/common/types/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/common/types/resolvables.d.ts

@@ -0,0 +1,10 @@
+import type { APIPartialEmoji, EmbedColors } from '..';
+import type { Attachment, AttachmentDataType, AttachmentResolvable } from '../../builders';
+import type { GuildMember } from '../../structures';
+export type EmojiResolvable = string | Partial<APIPartialEmoji> | `<${string | undefined}:${string}:${string}>`;
+export type GuildMemberResolvable = string | Partial<GuildMember>;
+export type ColorResolvable = `#${string}` | number | keyof typeof EmbedColors | 'Random' | [number, number, number];
+export type ImageResolvable = {
+    data: AttachmentResolvable;
+    type: AttachmentDataType;
+} | Attachment;

package/lib/common/types/resolvables.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/common/types/util.d.ts

@@ -0,0 +1,90 @@
+import type { GatewayIntentBits, PermissionFlagsBits } from '..';
+export type ToClass<T, This> = new (...args: any[]) => {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? ReturnType<T[K]> extends Promise<T> ? (...args: Parameters<T[K]>) => Promise<This> : ReturnType<T[K]> extends T ? (...args: Parameters<T[K]>) => This : T[K] : T[K];
+};
+export type StringToNumber<T extends string> = T extends `${infer N extends number}` ? N : never;
+export type MakePartial<T, K extends keyof T> = T & {
+    [P in K]?: T[P];
+};
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends Record<any, any> ? DeepPartial<T[K]> : T[K] extends (infer I)[] ? DeepPartial<I>[] : T[K];
+};
+export type OmitInsert<T, K extends keyof T, I> = I extends [] ? Omit<T, K> & I[number] : Omit<T, K> & I;
+export type IntentStrings = (keyof typeof GatewayIntentBits)[];
+export type PermissionStrings = (keyof typeof PermissionFlagsBits)[];
+export type RestOrArray<T> = T[] | [T[]];
+export interface StructWhen<Prop = any, State extends keyof StructWhen = 'cached'> {
+    cached: Prop | undefined;
+    api: State extends 'api' ? Prop : undefined;
+    create: State extends 'create' ? Prop : undefined;
+}
+export type StructStates = keyof StructWhen;
+export type StructPropState<Prop, State extends StructStates, Select extends StructStates> = StructWhen<Prop, Select>[State];
+export type WithID<More> = {
+    id: string;
+} & More;
+export type Tail<A> = A extends [unknown, ...infer rest] ? rest : A extends [unknown] ? [] : A extends (infer first)[] ? first[] : never;
+export type ValueOf<T> = T[keyof T];
+export type ArrayFirsElement<A> = A extends [...infer arr] ? arr[0] : never;
+export type RestToKeys<T extends unknown[]> = T extends [infer V, ...infer Keys] ? {
+    [K in Extract<Keys[number], string>]: V;
+} : never;
+export type Identify<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+export type TypeArray<T> = T | T[];
+export type When<T extends boolean, A, B = never> = T extends true ? A : B;
+export type If<T extends boolean, A, B = null> = T extends true ? A : B extends null ? A | null : B;
+export type PickPartial<T, K extends keyof T> = {
+    [P in keyof T]?: T[P] | undefined;
+} & {
+    [P in K]: T[P];
+};
+export type MakeRequired<T, K extends keyof T> = T & {
+    [P in K]-?: NonFalsy<T[P]>;
+};
+export type NonFalsy<T> = T extends false | 0 | '' | null | undefined | 0n ? never : T;
+export type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : Lowercase<S>;
+export type SnakeCase<S extends string> = S extends `${infer A}${infer Rest}` ? A extends Uppercase<A> ? `_${Lowercase<A>}${SnakeCase<Rest>}` : `${A}${SnakeCase<Rest>}` : Lowercase<S>;
+export type ObjectToLower<T> = Identify<{
+    [K in keyof T as CamelCase<Exclude<K, symbol | number>>]: T[K] extends unknown[] ? Identify<ObjectToLower<T[K][0]>[]> : T[K] extends object ? Identify<ObjectToLower<T[K]>> : T[K];
+}>;
+export type ObjectToSnake<T> = Identify<{
+    [K in keyof T as SnakeCase<Exclude<K, symbol | number>>]: T[K] extends unknown[] ? Identify<ObjectToSnake<T[K][0]>[]> : T[K] extends object ? Identify<ObjectToSnake<T[K]>> : T[K];
+}>;
+export type UnionToTuple<U, A extends any[] = []> = (U extends void ? void : (arg: () => U) => never) extends (arg: infer I) => void ? I extends () => infer W ? UnionToTuple<Exclude<U, W>, [W, ...A]> : A : never;
+export type KeysWithUndefined<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : null extends T[K] ? K : never;
+}[keyof T];
+type OptionalizeAux<T extends object> = Identify<{
+    [K in KeysWithUndefined<T>]?: T[K] extends ObjectLiteral ? Optionalize<T[K]> : T[K];
+} & {
+    [K in Exclude<keyof T, KeysWithUndefined<T>>]: T[K] extends ObjectLiteral ? Optionalize<T[K]> : T[K];
+}>;
+/**
+ * Makes all of properties in T optional when they're null | undefined
+ * it is recursive
+ */
+export type Optionalize<T> = T extends object ? T extends Array<unknown> ? number extends T['length'] ? T[number] extends object ? Array<OptionalizeAux<T[number]>> : T : Partial<T> : OptionalizeAux<T> : T;
+export type ObjectLiteral<T = unknown> = {
+    [K in PropertyKey]: T;
+};
+export type DropT<T, R> = {
+    [P in keyof T as T[P] extends R ? never : P]: T[P] extends R ? never : T[P];
+};
+export type DropTI<T, U> = {
+    [P in keyof T as U extends T[P] ? never : P]: U extends T[P] ? never : T[P];
+};
+export type KeepT<T, R> = {
+    [P in keyof T as T[P] extends R ? P : never]: T[P] extends R ? T[P] : never;
+};
+export type KeepTI<T, U> = {
+    [P in keyof T as U extends T[P] ? P : never]: U extends T[P] ? T[P] : never;
+};
+export type Clean<T> = DropT<T, never>;
+export type PartialAvoid<U, T> = Identify<KeepT<T, U> & Partial<T>>;
+export type PartialClass<T> = PartialAvoid<Function, T>;
+export type AtLeastOne<T, U = {
+    [K in keyof T]: Pick<T, K>;
+}> = Partial<T> & U[keyof U];
+export {};

package/lib/common/types/util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/common/types/write.d.ts

@@ -0,0 +1,21 @@
+import type { APIActionRowComponent, APIEmbed, APIInteractionResponseCallbackData, APIInteractionResponseChannelMessageWithSource, APIMessageActionRowComponent, APIModalInteractionResponse, RESTPatchAPIChannelMessageJSONBody, RESTPatchAPIWebhookWithTokenMessageJSONBody, RESTPostAPIChannelMessageJSONBody, RESTPostAPIWebhookWithTokenJSONBody } from '..';
+import type { RawFile } from '../../api';
+import type { ActionRow, Attachment, BuilderComponents, Embed, Modal, TextInput } from '../../builders';
+import type { ComponentsListener } from '../../components/listener';
+import type { OmitInsert } from './util';
+export type BodyModalComponentProper = {
+    components?: ActionRow<TextInput>[] | undefined;
+};
+export interface ResolverProps {
+    embeds?: Embed[] | APIEmbed[] | undefined;
+    components?: ComponentsListener<BuilderComponents> | APIActionRowComponent<APIMessageActionRowComponent>[] | ActionRow<BuilderComponents>[] | undefined;
+    files?: Attachment[] | RawFile[] | undefined;
+}
+export type MessageCreateBodyRequest = OmitInsert<RESTPostAPIChannelMessageJSONBody, 'components' | 'embeds', ResolverProps>;
+export type MessageUpdateBodyRequest = OmitInsert<RESTPatchAPIChannelMessageJSONBody, 'components' | 'embeds', ResolverProps>;
+export type MessageWebhookCreateBodyRequest = OmitInsert<RESTPostAPIWebhookWithTokenJSONBody, 'components' | 'embeds', ResolverProps>;
+export type MessageWebhookUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds', ResolverProps>;
+export type InteractionMessageUpdateBodyRequest = OmitInsert<RESTPatchAPIWebhookWithTokenMessageJSONBody, 'components' | 'embeds', ResolverProps>;
+export type ComponentInteractionMessageUpdate = OmitInsert<APIInteractionResponseCallbackData, 'components' | 'embeds', ResolverProps>;
+export type InteractionCreateBodyRequest = OmitInsert<APIInteractionResponseChannelMessageWithSource['data'], 'components' | 'embeds', ResolverProps>;
+export type ModalCreateBodyRequest = APIModalInteractionResponse['data'] | Modal;

package/lib/common/types/write.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/components/ActionRow.d.ts

@@ -0,0 +1,10 @@
+import type { APIMessageActionRowComponent, ComponentType } from '../common';
+import { BaseComponent } from '../structures/extra/BaseComponent';
+import type { ActionRowMessageComponents } from './index';
+export declare class MessageActionRowComponent<T extends ActionRowMessageComponents> extends BaseComponent<ComponentType.ActionRow> {
+    constructor(data: {
+        type: ComponentType.ActionRow;
+        components: APIMessageActionRowComponent[];
+    });
+    components: T[];
+}

package/lib/components/ActionRow.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageActionRowComponent = void 0;
+const BaseComponent_1 = require("../structures/extra/BaseComponent");
+const index_1 = require("./index");
+class MessageActionRowComponent extends BaseComponent_1.BaseComponent {
+    constructor(data) {
+        super(data);
+        this.components = data.components.map(index_1.componentFactory);
+    }
+    components;
+}
+exports.MessageActionRowComponent = MessageActionRowComponent;

package/lib/components/ButtonComponent.d.ts

@@ -0,0 +1,19 @@
+import type { APIButtonComponentWithCustomId, APIButtonComponentWithURL, APIMessageComponentEmoji, ComponentType } from '../common';
+import { ButtonStyle } from '../common';
+import { BaseComponent } from '../structures/extra/BaseComponent';
+export declare class LinkButtonComponent extends BaseComponent<ComponentType.Button> {
+    constructor(data: APIButtonComponentWithURL);
+    style: ButtonStyle;
+    label?: string;
+    emoji?: APIMessageComponentEmoji;
+    disabled: boolean;
+    url: string;
+}
+export type ButtonStyleExludeLink = Exclude<ButtonStyle, ButtonStyle.Link>;
+export declare class ButtonComponent extends BaseComponent<ComponentType.Button> {
+    constructor(data: APIButtonComponentWithCustomId);
+    style: ButtonStyleExludeLink;
+    label?: string;
+    emoji?: APIMessageComponentEmoji;
+    disabled: boolean;
+}

package/lib/components/ButtonComponent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ButtonComponent = exports.LinkButtonComponent = void 0;
+const common_1 = require("../common");
+const BaseComponent_1 = require("../structures/extra/BaseComponent");
+class LinkButtonComponent extends BaseComponent_1.BaseComponent {
+    constructor(data) {
+        super(data);
+        this.label = data.label;
+        this.emoji = data.emoji;
+        this.disabled = !!data.disabled;
+        this.url = data.url;
+    }
+    style = common_1.ButtonStyle.Link;
+    label;
+    emoji;
+    disabled;
+    url;
+}
+exports.LinkButtonComponent = LinkButtonComponent;
+class ButtonComponent extends BaseComponent_1.BaseComponent {
+    constructor(data) {
+        super(data);
+        this.style = data.style;
+        this.label = data.label;
+        this.emoji = data.emoji;
+        this.disabled = !!data.disabled;
+    }
+    style;
+    label;
+    emoji;
+    disabled;
+}
+exports.ButtonComponent = ButtonComponent;

package/lib/components/ChannelSelectMenuComponent.d.ts

@@ -0,0 +1,6 @@
+import type { APIChannelSelectComponent, ChannelType, ComponentType } from '../common';
+import { BaseSelectMenuComponent } from '../structures/extra/BaseSelectMenuComponent';
+export declare class ChannelSelectMenuComponent extends BaseSelectMenuComponent<ComponentType.ChannelSelect> {
+    constructor(data: APIChannelSelectComponent);
+    channelTypes?: ChannelType[];
+}

package/lib/components/ChannelSelectMenuComponent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSelectMenuComponent = void 0;
+const BaseSelectMenuComponent_1 = require("../structures/extra/BaseSelectMenuComponent");
+class ChannelSelectMenuComponent extends BaseSelectMenuComponent_1.BaseSelectMenuComponent {
+    constructor(data) {
+        super(data);
+        this.channelTypes = data.channel_types;
+    }
+    channelTypes;
+}
+exports.ChannelSelectMenuComponent = ChannelSelectMenuComponent;

package/lib/components/MentionableSelectMenuComponent.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentType } from '../common';
+import { BaseSelectMenuComponent } from '../structures/extra/BaseSelectMenuComponent';
+export declare class MentionableSelectMenuComponent extends BaseSelectMenuComponent<ComponentType.MentionableSelect> {
+}