bakit 2.2.3 → 3.0.0

package/dist/index.d.ts

@@ -1,148 +1,276 @@
-import { REST } from '@bakit/rest';
-export { REST, RESTEndpoint, RESTEvents, RESTMethod, RESTOptions, createREST } from '@bakit/rest';
-import { EventBus } from '@bakit/utils';
-export { Awaitable, Collection, EventBus, EventMap, FunctionLike, Promisify, PromisifyValue, Queue, QueueOptions, ReadonlyCollection, RejectFn, ResolveFn, attachEventBus, capitalize, createEventBus, createQueue, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
-import { APIUser, APIMessage, ChannelType, Snowflake, APIChannel, APIChannelBase, APIGuildTextChannel, APIDMChannel, APIPublicThreadChannel, APIPrivateThreadChannel, APITextBasedChannel, TextChannelType, APIGuildChannel, GuildTextChannelType, APIThreadChannel, MessageFlags, GatewayReceivePayload } from 'discord-api-types/v10';
-import { GatewayMessageCreateDispatchData } from 'discord-api-types/v9';
-import * as discord_api_types_globals from 'discord-api-types/globals';
-export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, GatewayManager, GatewayManagerEvents, GatewayManagerOptions, GatewayWorker, GatewayWorkerEvents, GatewayWorkerOptions, GatewayWorkerState, createGatewayManager, createWorker } from '@bakit/gateway';
-export { RPCError, RPCErrorPayload, RPCHandler, RPCRequestMessage, RPCResponseMessage, Serializable, Service, ServiceFunction, ServiceOptions, TransportClient, TransportClientOptions, TransportDriver, TransportServer, TransportServerOptions, createIPCClient, createIPCServer, createService, createTransportClient, createTransportServer, deserializeRPCError, getIPCPath, serializeRPCError } from '@bakit/service';
+import { ShardingManagerOptions, ShardingManager } from '@bakit/gateway';
+export { Cluster, ClusterEvents, ClusterOptions, Shard, ShardEvents, ShardOptions, ShardState, ShardStrategy, ShardingManager, ShardingManagerEvents, ShardingManagerOptions } from '@bakit/gateway';
+import { RESTLike } from '@bakit/rest';
+export { BaseRESTEvents, DEFAULT_REST_OPTIONS, DiscordHTTPError, DiscordHTTPErrorRequest, DiscordHTTPFlattenedError, DiscordHTTPValidationError, REST, RESTAdapter, RESTAdapterEvents, RESTEndpoint, RESTEvents, RESTLike, RESTMethod, RESTOptions, RESTProxyOptions, RESTRequestFn, RESTRequestOptions, createREST, createRESTAdapter } from '@bakit/rest';
+export { RPCHandler, Service, ServiceClientRuntime, ServiceDriver, ServiceOptions, ServiceProcess, ServiceProcessEvents, ServiceServerRuntime, ServiceState, TransportClient, TransportClientEvents, TransportServer, TransportServerEvents, createService, createTransportClient, createTransportServer } from '@bakit/service';
+import * as _bakit_utils from '@bakit/utils';
+export { AbstractConstructor, Awaitable, Constructor, FunctionLike, Promisify, PromisifyValue, RejectFn, ResolveFn, capitalize, instanceToObject, isCommonJS, isESM, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
+import EventEmitter from 'node:events';
+import { Collection } from '@discordjs/collection';
+import * as discord_api_types_v10 from 'discord-api-types/v10';
+import { APITextBasedChannel, ChannelType, APIGuildVoiceChannel, APIChannelBase, GatewayChannelCreateDispatchData, GatewayChannelUpdateDispatchData, APIChannel, APIGuild, GatewayGuildUpdateDispatchData, GatewayGuildCreateDispatchData, APIUser, GatewayReadyDispatchData, APIEmbed, APIAllowedMentions, APIMessageReference, APIMessage, GatewayMessageCreateDispatchData, GatewayMessageUpdateDispatchData, GatewayIntentBits, GatewayDispatchPayload, GatewayReceivePayload } from 'discord-api-types/v10';
+export { discord_api_types_v10 as DiscordAPIV10 };
+export { GatewayIntentBits as Intent } from 'discord-api-types/v10';
 
-interface User {
-    readonly client: Client;
-    readonly id: string;
-    readonly username: string;
-    readonly discriminator: string;
-    readonly globalName?: string | null;
-    readonly avatar?: string | null;
-    readonly system?: boolean;
-    readonly mfaEnabled?: boolean;
-    readonly banner?: string | null;
-    readonly accentColor?: number;
-    readonly locale?: string;
-    readonly verified?: boolean;
-    readonly email?: string | null;
-    readonly flags?: number;
-    readonly premiumType?: number;
-    readonly publicFlags?: number;
+declare class BaseStructure {
+    client: Client;
+    constructor(client: Client);
+    toJSON(): {};
 }
-declare function createUser(client: Client, data: APIUser): User;
 
-interface Message {
-    readonly client: Client;
-    readonly id: string;
-    readonly channelId: string;
-    readonly guildId?: string;
-    readonly author: User;
-    readonly content: string;
-    readonly timestamp: string;
-    readonly editedTimestamp?: string;
-    readonly tts: boolean;
-    readonly mentionEveryone: boolean;
-    readonly mentions: readonly User[];
-    readonly mentionRoles: readonly string[];
-    readonly nonce?: string | number;
-    readonly pinned: boolean;
-    readonly webhookId?: string;
-    readonly type: number;
-    readonly applicationId?: string;
-    readonly flags?: number;
-    readonly referencedMessage?: Message;
-    readonly position?: number;
+declare const GuildTextChannel_base: (abstract new (client: Client, data: APITextBasedChannel<ChannelType.GuildText>) => BaseChannel<APITextBasedChannel<ChannelType.GuildText>>) & (abstract new (...args: any[]) => {
+    get guildId(): string;
+    get guild(): Guild;
+    data: discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>;
+    get id(): string;
+    get type(): ChannelType;
+    toString(): string;
+    toJSON(): discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>;
+    isTextBased(): this is TextBasedChannel;
+    isVoiceBased(): this is VoiceBasedChannel;
+    inGuild(): this is GuildChannel;
+    _patch(data: Partial<discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>>): void;
+    client: Client;
+}) & _bakit_utils.AbstractConstructor<BaseChannel<discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>>> & (abstract new (...args: any[]) => {
+    send(options: MessageCreateOptions): Promise<discord_api_types_v10.APIMessage>;
+    data: APITextBasedChannel<ChannelType>;
+    get id(): string;
+    get type(): ChannelType;
+    toString(): string;
+    toJSON(): APITextBasedChannel<ChannelType>;
+    isTextBased(): this is TextBasedChannel;
+    isVoiceBased(): this is VoiceBasedChannel;
+    inGuild(): this is GuildChannel;
+    _patch(data: Partial<APITextBasedChannel<ChannelType>>): void;
+    client: Client;
+}) & _bakit_utils.AbstractConstructor<BaseChannel<APITextBasedChannel<ChannelType>>>;
+declare class GuildTextChannel extends GuildTextChannel_base {
 }
-declare function createMessage(client: Client, data: APIMessage | GatewayMessageCreateDispatchData): Message;
 
-interface TextBasedChannelSingleton {
-    lastMessageId?: Snowflake;
-    send(content: string): Promise<Message>;
-    send(options: CreateMessageOptions): Promise<Message>;
-    send(options: CreateMessageOptions | string): Promise<Message>;
+declare const GuildVoiceChannel_base: (abstract new (client: Client, data: APIGuildVoiceChannel) => BaseChannel<APIGuildVoiceChannel>) & (abstract new (...args: any[]) => {
+    get guildId(): string;
+    get guild(): Guild;
+    data: discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>;
+    get id(): string;
+    get type(): discord_api_types_v10.ChannelType;
+    toString(): string;
+    toJSON(): discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>;
+    isTextBased(): this is TextBasedChannel;
+    isVoiceBased(): this is VoiceBasedChannel;
+    inGuild(): this is GuildChannel;
+    _patch(data: Partial<discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>>): void;
+    client: Client;
+}) & _bakit_utils.AbstractConstructor<BaseChannel<discord_api_types_v10.APIGuildChannel<discord_api_types_v10.GuildChannelType>>> & (abstract new (...args: any[]) => {
+    send(options: MessageCreateOptions): Promise<discord_api_types_v10.APIMessage>;
+    data: discord_api_types_v10.APITextBasedChannel<discord_api_types_v10.ChannelType>;
+    get id(): string;
+    get type(): discord_api_types_v10.ChannelType;
+    toString(): string;
+    toJSON(): discord_api_types_v10.APITextBasedChannel<discord_api_types_v10.ChannelType>;
+    isTextBased(): this is TextBasedChannel;
+    isVoiceBased(): this is VoiceBasedChannel;
+    inGuild(): this is GuildChannel;
+    _patch(data: Partial<discord_api_types_v10.APITextBasedChannel<discord_api_types_v10.ChannelType>>): void;
+    client: Client;
+}) & _bakit_utils.AbstractConstructor<BaseChannel<discord_api_types_v10.APITextBasedChannel<discord_api_types_v10.ChannelType>>> & (abstract new (...args: any[]) => {
+    data: discord_api_types_v10.APIVoiceChannelBase<discord_api_types_v10.GuildChannelType>;
+    get id(): string;
+    get type(): discord_api_types_v10.ChannelType;
+    toString(): string;
+    toJSON(): discord_api_types_v10.APIVoiceChannelBase<discord_api_types_v10.GuildChannelType>;
+    isTextBased(): this is TextBasedChannel;
+    isVoiceBased(): this is VoiceBasedChannel;
+    inGuild(): this is GuildChannel;
+    _patch(data: Partial<discord_api_types_v10.APIVoiceChannelBase<discord_api_types_v10.GuildChannelType>>): void;
+    client: Client;
+}) & _bakit_utils.AbstractConstructor<BaseChannel<discord_api_types_v10.APIVoiceChannelBase<discord_api_types_v10.GuildChannelType>>>;
+declare class GuildVoiceChannel extends GuildVoiceChannel_base {
 }
-interface VoiceBasedChannelSingleton {
-    join(): Promise<void>;
+
+type BaseChannelPayload = APIChannelBase<ChannelType> | GatewayChannelCreateDispatchData | GatewayChannelUpdateDispatchData | APIChannel;
+type TextBasedChannel = GuildTextChannel | GuildVoiceChannel;
+type VoiceBasedChannel = GuildVoiceChannel;
+type GuildChannel = GuildTextChannel | GuildVoiceChannel;
+type Channel = TextBasedChannel | VoiceBasedChannel | GuildChannel;
+declare abstract class BaseChannel<D extends BaseChannelPayload> extends BaseStructure {
+    data: D;
+    constructor(client: Client, data: D);
+    get id(): string;
+    get type(): ChannelType;
+    toString(): string;
+    toJSON(): D;
+    isTextBased(): this is TextBasedChannel;
+    isVoiceBased(): this is VoiceBasedChannel;
+    inGuild(): this is GuildChannel;
+    _patch(data: Partial<D>): void;
 }
-interface GuildBasedChannelSingleton {
-    readonly name: string;
-    readonly guildId?: Snowflake;
-    readonly parentId?: Snowflake;
+
+type GuildPayload = APIGuild | GatewayGuildUpdateDispatchData | GatewayGuildCreateDispatchData;
+declare class Guild extends BaseStructure {
+    data: GuildPayload;
+    private cachedChannels;
+    constructor(client: Client, data: GuildPayload);
+    get id(): string;
+    get name(): string;
+    get icon(): string | null;
+    get banner(): string | null;
+    get owner(): string;
+    get mfaLevel(): discord_api_types_v10.GuildMFALevel;
+    get verificationLevel(): discord_api_types_v10.GuildVerificationLevel;
+    get channels(): Collection<string, Channel>;
+    _patch(data: Partial<GuildPayload>): void;
 }
-interface GuildTextBasedChannelSingleton extends GuildBasedChannelSingleton, TextBasedChannelSingleton {
+
+type UserPayload = APIUser | GatewayReadyDispatchData["user"];
+declare class User extends BaseStructure {
+    data: UserPayload;
+    constructor(client: Client, data: UserPayload);
+    get id(): string;
+    get username(): string;
+    get discriminator(): string;
+    get globalName(): string | null;
+    get tag(): string;
+    get displayName(): string;
+    get avatar(): string | undefined;
+    get bot(): boolean;
+    get system(): boolean;
+    get mfaEnabled(): boolean | undefined;
+    get locale(): string | undefined;
+    get verified(): boolean | undefined;
+    get email(): string | null | undefined;
+    get flags(): discord_api_types_v10.UserFlags | undefined;
+    get premiumType(): discord_api_types_v10.UserPremiumType | undefined;
+    get publicFlags(): discord_api_types_v10.UserFlags | undefined;
+    get banner(): string | null | undefined;
+    get accentColor(): number | undefined;
+    get createdAt(): Date;
+    get createdTimestamp(): number;
+    get hexAccentColor(): string | undefined;
+    get defaultAvatarURL(): string;
+    getAvatarURL(options?: {
+        size?: number;
+        extension?: "png" | "jpg" | "webp" | "gif";
+    }): string | undefined;
+    getDisplayAvatarURL(options?: {
+        size?: number;
+        extension?: "png" | "jpg" | "webp" | "gif";
+    }): string;
+    equals(other: User | string): boolean;
+    toJSON(): APIUser;
+    toString(): string;
 }
-interface ThreadBasedChannelSingleton extends GuildTextBasedChannelSingleton {
-    readonly messageCount?: number;
-    readonly memberCount?: number;
-    readonly ownerId?: Snowflake;
-    readonly totalMessageSent?: number;
-    readonly appliedTags?: Snowflake[];
+
+interface MessageCreateOptions {
+    content?: string;
+    tts?: boolean;
+    embeds?: APIEmbed[];
+    allowedMentions?: APIAllowedMentions;
+    messageReference?: APIMessageReference;
+    flags?: number;
 }
-interface BaseChannel {
+type MessageReplyOptions = Omit<MessageCreateOptions, "messageReference">;
+declare class ClientHelper {
     readonly client: Client;
-    readonly id: string;
-    readonly type: ChannelType;
-    isTextBased(): this is GuildTextChannel | DMChannel | PublicThreadChannel | PrivateThreadChannel;
-    isVoiceBased(): this is VoiceChannel | StageChannel;
-    isGuildBased(): this is GuildTextChannel | VoiceChannel | StageChannel | PublicThreadChannel | PrivateThreadChannel;
-    isThreadBased(): this is PublicThreadChannel | PrivateThreadChannel;
-    isDm(): this is DMChannel;
-    isGuildText(): this is GuildTextChannel;
-    isVoice(): this is VoiceChannel;
-    isStage(): this is StageChannel;
-    isPublicThread(): this is PublicThreadChannel;
-    isPrivateThread(): this is PrivateThreadChannel;
-}
-interface DMChannel extends BaseChannel, TextBasedChannelSingleton {
-    readonly recipients?: User[];
-}
-interface GuildTextChannel extends BaseChannel, GuildTextBasedChannelSingleton {
-}
-interface VoiceChannel extends GuildTextChannel, VoiceBasedChannelSingleton {
-}
-interface StageChannel extends GuildTextChannel, VoiceBasedChannelSingleton {
-}
-interface PublicThreadChannel extends BaseChannel, ThreadBasedChannelSingleton {
+    constructor(client: Client);
+    fetchMessage(channelId: string, messageId: string): Promise<Message>;
+    deleteMessage(channelId: string, messageId: string): Promise<unknown>;
+    createMessage(channelId: string, options: MessageCreateOptions): Promise<APIMessage>;
+    replyMessage(channelId: string, messageId: string, options: MessageReplyOptions): Promise<APIMessage>;
+    fetchGuild(guildId: string): Promise<Guild>;
+    static toAPICreateMessagePayload(options: MessageCreateOptions): {
+        content: string | undefined;
+        tts: boolean | undefined;
+        embeds: APIEmbed[] | undefined;
+        allowed_mentions: APIAllowedMentions | undefined;
+        message_reference: APIMessageReference | undefined;
+        flags: number | undefined;
+    };
 }
-interface PrivateThreadChannel extends BaseChannel, ThreadBasedChannelSingleton {
+
+type MessagePayload = APIMessage | GatewayMessageCreateDispatchData | GatewayMessageUpdateDispatchData;
+declare class Message extends BaseStructure {
+    data: MessagePayload;
+    protected cachedAuthor?: User;
+    constructor(client: Client, data: MessagePayload);
+    get partial(): boolean;
+    get content(): string;
+    get id(): string;
+    get channelId(): string;
+    get channel(): TextBasedChannel;
+    get guildId(): string | undefined;
+    get guild(): Guild | undefined;
+    get author(): User;
+    get createdAt(): Date;
+    get editedAt(): Date | undefined;
+    get createdTimestamp(): number;
+    get editedTimestamp(): number | undefined;
+    get url(): string;
+    fetch(): Promise<Message>;
+    reply(options: MessageReplyOptions): Promise<APIMessage>;
+    sendToChannel(options: MessageReplyOptions): Promise<APIMessage>;
+    toJSON(): MessagePayload;
+    toString(): string;
 }
-type Channel = GuildTextChannel | DMChannel | PublicThreadChannel | VoiceChannel | StageChannel | BaseChannel;
-declare function createChannel(client: Client, data: APIChannel): Channel;
-declare function createBaseChannel(client: Client, data: APIChannelBase<ChannelType>): BaseChannel;
-declare function createGuildTextChannel(client: Client, data: APIGuildTextChannel<ChannelType.GuildText>): GuildTextChannel;
-declare function createDMChannel(client: Client, data: APIDMChannel): DMChannel;
-declare function createPublicThreadChannel(client: Client, data: APIPublicThreadChannel): PublicThreadChannel;
-declare function createPrivateThreadChannel(client: Client, data: APIPrivateThreadChannel): PrivateThreadChannel;
-declare function createVoiceChannel(client: Client, data: APIGuildTextChannel<ChannelType.GuildVoice>): VoiceChannel;
-declare function createStageChannel(client: Client, data: APIGuildTextChannel<ChannelType.GuildStageVoice>): StageChannel;
-declare function createTextBasedChannelSingleton(client: Client, data: APITextBasedChannel<TextChannelType>): TextBasedChannelSingleton;
-declare function createVoiceBasedChannelSingleton(_client: Client, _data: APIChannelBase<ChannelType.GuildVoice> | APIChannelBase<ChannelType.GuildStageVoice>): VoiceBasedChannelSingleton;
-declare function createGuildBasedChannelSingleton(data: APIGuildChannel): GuildBasedChannelSingleton;
-declare function createGuildTextBasedChannelSingleton(client: Client, data: APIGuildTextChannel<GuildTextChannelType>): GuildTextBasedChannelSingleton;
-declare function createThreadBasedChannelSingleton(client: Client, data: APIThreadChannel): ThreadBasedChannelSingleton;
 
-interface CreateMessageOptions {
-    content?: string;
-    flags?: MessageFlags;
+declare enum Partial$1 {
+    Message = 0,
+    User = 1
 }
 
-declare function createHelpers(client: Client): {
-    user: {
-        getById(id: discord_api_types_globals.Snowflake): Promise<User | undefined>;
-        getCurrent(): Promise<User>;
-    };
-    channel: {
-        getById(id: discord_api_types_globals.Snowflake): Promise<Channel | undefined>;
-        createMessage(channelId: discord_api_types_globals.Snowflake, options: CreateMessageOptions | string): Promise<Message>;
-        deleteMessage(channelId: discord_api_types_globals.Snowflake, messageId: discord_api_types_globals.Snowflake): Promise<void>;
-    };
-};
+type IntentResolvable = number | bigint | GatewayIntentBits | GatewayIntentBits[];
+declare class IntentsBitField {
+    private readonly value;
+    constructor(input: IntentResolvable);
+    static resolve(input: IntentResolvable): bigint;
+    has(intent: GatewayIntentBits): boolean;
+    toBigInt(): bigint;
+    toNumber(): number;
+    toJSON(): string;
+    toString(): string;
+}
 
-interface Client extends EventBus<ClientEvents> {
-    rest: REST;
-    helpers: ReturnType<typeof createHelpers>;
+interface ClientOptions {
+    token: string;
+    intents: IntentResolvable | IntentsBitField;
+    sharding?: ClientShardingOptions;
+    partials?: Partial$1[];
 }
+type ClientShardingOptions = Omit<ShardingManagerOptions, "token" | "intents">;
 interface ClientEvents {
-    raw: [payload: GatewayReceivePayload];
+    ready: [user: User];
+    error: [error: Error];
+    dispatch: [shardId: number, payload: GatewayDispatchPayload];
+    raw: [shardId: number, payload: GatewayReceivePayload];
     messageCreate: [message: Message];
+    messageUpdate: [message: Message];
+    messageDelete: [message: {
+        id: string;
+        channelId: string;
+        guildId?: string;
+    }];
+    userUpdate: [user: User];
+    guildCreate: [guild: Guild];
+    guildAvailable: [guild: Guild];
+    guildUpdate: [guild: Guild];
+    guildDelete: [guild: Guild];
+    channelCreate: [channel: Channel];
+    channelUpdate: [channel: Channel];
+    channelDelete: [channel: Channel];
+}
+declare class Client extends EventEmitter<ClientEvents> {
+    #private;
+    readonly options: Omit<Required<ClientOptions>, "partials" | "intents"> & {
+        partials: Set<Partial$1>;
+        intents: IntentsBitField;
+    };
+    readonly shards: ShardingManager;
+    readonly rest: RESTLike;
+    readonly helper: ClientHelper;
+    readonly guilds: Collection<string, Guild>;
+    constructor(options: ClientOptions, rest?: RESTLike);
+    get user(): User | undefined;
+    login(): Promise<void>;
 }
-declare function createClient(rest: REST): Client;
+declare function createClient(options: ClientOptions): Client;
 
-export { type BaseChannel, type Channel, type Client, type ClientEvents, type DMChannel, type GuildBasedChannelSingleton, type GuildTextBasedChannelSingleton, type GuildTextChannel, type Message, type PrivateThreadChannel, type PublicThreadChannel, type StageChannel, type TextBasedChannelSingleton, type ThreadBasedChannelSingleton, type User, type VoiceBasedChannelSingleton, type VoiceChannel, createBaseChannel, createChannel, createClient, createDMChannel, createGuildBasedChannelSingleton, createGuildTextBasedChannelSingleton, createGuildTextChannel, createMessage, createPrivateThreadChannel, createPublicThreadChannel, createStageChannel, createTextBasedChannelSingleton, createThreadBasedChannelSingleton, createUser, createVoiceBasedChannelSingleton, createVoiceChannel };
+export { BaseChannel, type BaseChannelPayload, type Channel, Client, type ClientEvents, ClientHelper, type ClientOptions, type ClientShardingOptions, Guild, type GuildChannel, type GuildPayload, GuildTextChannel, GuildVoiceChannel, type IntentResolvable, IntentsBitField, Message, type MessageCreateOptions, type MessagePayload, type MessageReplyOptions, Partial$1 as Partial, type TextBasedChannel, User, type UserPayload, type VoiceBasedChannel, createClient };