seyfert 1.5.0 → 2.0.0

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 import { type BaseClientOptions, type InternalRuntimeConfig, type InternalRuntimeConfigHTTP, type RuntimeConfig, type RuntimeConfigHTTP } from './client/base';
-import type { CustomEventsKeys, ClientNameEvents, EventContext } from './events';
-export { Logger, PermissionStrings, Watcher, Formatter } from './common';
+import type { CustomEventsKeys, ClientNameEvents, ResolveEventParams } from './events';
+export { Logger, PermissionStrings, Formatter } from './common';
 export { Collection, LimitedCollection } from './collection';
 export * from './api';
 export * from './builders';
@@ -12,7 +12,6 @@ export * from './langs';
 export { ShardManager, WorkerManager } from './websocket/discord';
 export * from './structures';
 export * from './client';
-export declare function throwError(msg: string): never;
 /**
  * Creates an event with the specified data and run function.
  *
@@ -32,21 +31,13 @@ export declare function createEvent<E extends ClientNameEvents | CustomEventsKey
         name: E;
         once?: boolean;
     };
-    run: (...args: EventContext<{
-        data: {
-            name: E;
-        };
-    }>) => any;
+    run: (...args: ResolveEventParams<E>) => any;
 }): {
     data: {
         name: E;
         once?: boolean;
     };
-    run: (...args: EventContext<{
-        data: {
-            name: E;
-        };
-    }>) => any;
+    run: (...args: ResolveEventParams<E>) => any;
 };
 export declare const config: {
     /**
@@ -78,4 +69,4 @@ export declare const config: {
  * 	};
  * });
  */
-export declare function extendContext<T extends {}>(cb: (interaction: Parameters<NonNullable<BaseClientOptions['context']>>[0]) => T): (interaction: Parameters<NonNullable<BaseClientOptions['context']>>[0]) => T;
+export declare function extendContext<T extends {}>(cb: (interaction: Parameters<NonNullable<BaseClientOptions['context']>>[0]) => T): (interaction: Parameters<NonNullable<BaseClientOptions["context"]>>[0]) => T;

package/lib/index.js

@@ -14,13 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extendContext = exports.config = exports.createEvent = exports.throwError = exports.WorkerManager = exports.ShardManager = exports.LimitedCollection = exports.Collection = exports.Formatter = exports.Watcher = exports.Logger = void 0;
-const v10_1 = require("discord-api-types/gateway/v10");
+exports.config = exports.WorkerManager = exports.ShardManager = exports.LimitedCollection = exports.Collection = exports.Formatter = exports.Logger = void 0;
+exports.createEvent = createEvent;
+exports.extendContext = extendContext;
+const types_1 = require("./types");
 const base_1 = require("./client/base");
 const common_1 = require("./common");
 var common_2 = require("./common");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return common_2.Logger; } });
-Object.defineProperty(exports, "Watcher", { enumerable: true, get: function () { return common_2.Watcher; } });
 Object.defineProperty(exports, "Formatter", { enumerable: true, get: function () { return common_2.Formatter; } });
 //
 var collection_1 = require("./collection");
@@ -42,11 +43,7 @@ Object.defineProperty(exports, "WorkerManager", { enumerable: true, get: functio
 __exportStar(require("./structures"), exports);
 //
 __exportStar(require("./client"), exports);
-//
-function throwError(msg) {
-    throw new Error(msg);
-}
-exports.throwError = throwError;
+///
 /**
  * Creates an event with the specified data and run function.
  *
@@ -65,7 +62,6 @@ function createEvent(data) {
     data.data.once ??= false;
     return data;
 }
-exports.createEvent = createEvent;
 exports.config = {
     /**
      * Configurations for the bot.
@@ -79,7 +75,7 @@ exports.config = {
             intents: 'intents' in data
                 ? typeof data.intents === 'number'
                     ? data.intents
-                    : data.intents?.reduce((pr, acc) => pr | (typeof acc === 'number' ? acc : v10_1.GatewayIntentBits[acc]), 0) ?? 0
+                    : data.intents?.reduce((pr, acc) => pr | (typeof acc === 'number' ? acc : types_1.GatewayIntentBits[acc]), 0) ?? 0
                 : 0,
         };
     },
@@ -95,7 +91,7 @@ exports.config = {
             ...data,
         };
         if ((0, common_1.isCloudfareWorker)())
-            base_1.BaseClient._seyfertConfig = obj;
+            base_1.BaseClient._seyfertCfWorkerConfig = obj;
         return obj;
     },
 };
@@ -116,4 +112,3 @@ exports.config = {
 function extendContext(cb) {
     return cb;
 }
-exports.extendContext = extendContext;

package/lib/langs/handler.d.ts

@@ -1,21 +1,25 @@
-import type { LocaleString } from 'discord-api-types/v10';
 import { BaseHandler } from '../common';
+import type { FileLoaded } from '../commands/handler';
+import type { LocaleString } from '../types';
 export declare class LangsHandler extends BaseHandler {
     values: Partial<Record<string, any>>;
+    private __paths;
     protected filter: (path: string) => boolean;
     defaultLang?: string;
     aliases: [string, LocaleString[]][];
     getLocale(locale: string): string;
     getKey(lang: string, message: string): string | undefined;
     get(userLocale: string): import("./router").__InternalParseLocale<import("..").DefaultLocale> & {
-        get(locale?: string | undefined): import("..").DefaultLocale;
+        get(locale?: string): import("..").DefaultLocale;
     };
-    load(dir: string, instances?: {
-        name: string;
-        file: Record<string, any>;
-    }[]): Promise<void>;
-    setHandlers({ callback }: {
-        callback: LangsHandler['callback'];
-    }): void;
-    callback: (_locale: string, file: Record<string, any>) => Record<string, any> | false;
+    load(dir: string): Promise<void>;
+    parse(file: EventInstance): void;
+    set(instances: EventInstance[]): void;
+    reload(lang: string): Promise<false | Record<string, any> | null>;
+    reloadAll(stopIfFail?: boolean): Promise<void>;
+    onFile(_locale: string, file: FileLoaded<Record<string, any>>): Record<string, any> | false;
 }
+export type EventInstance = {
+    name: string;
+    file: Record<string, any>;
+};

package/lib/langs/handler.js

@@ -5,6 +5,7 @@ const common_1 = require("../common");
 const router_1 = require("./router");
 class LangsHandler extends common_1.BaseHandler {
     values = {};
+    __paths = {};
     filter = (path) => path.endsWith('.js') || (!path.endsWith('.d.ts') && path.endsWith('.ts')) || path.endsWith('.json');
     defaultLang;
     aliases = [];
@@ -30,18 +31,48 @@ class LangsHandler extends common_1.BaseHandler {
         const locale = this.getLocale(userLocale);
         return (0, router_1.LangRouter)(locale, this.defaultLang ?? locale, this.values)();
     }
-    async load(dir, instances) {
-        const files = instances ?? (await this.loadFilesK(await this.getFiles(dir)));
+    async load(dir) {
+        const files = await this.loadFilesK(await this.getFiles(dir));
         for (const i of files) {
-            const locale = i.name.split('.').slice(0, -1).join('.') || i.name;
-            const result = this.callback(locale, i.file);
-            if (result)
-                this.values[locale] = result;
+            this.parse(i);
         }
     }
-    setHandlers({ callback }) {
-        this.callback = callback;
+    parse(file) {
+        const locale = file.name.split('.').slice(0, -1).join('.') || file.name;
+        const result = this.onFile(locale, file.file);
+        if ('path' in file)
+            this.__paths[locale] = file.path;
+        if (result)
+            this.values[locale] = result;
+    }
+    set(instances) {
+        for (const i of instances) {
+            this.parse(i);
+        }
+    }
+    async reload(lang) {
+        if ((0, common_1.isCloudfareWorker)()) {
+            throw new Error('Reload in cloudfare worker is not supported');
+        }
+        const value = this.__paths[lang];
+        if (!value)
+            return null;
+        delete require.cache[value];
+        return (this.values[lang] = await (0, common_1.magicImport)(value).then(x => this.onFile(lang, x)));
+    }
+    async reloadAll(stopIfFail = true) {
+        for (const i in this.__paths) {
+            try {
+                await this.reload(i);
+            }
+            catch (e) {
+                if (stopIfFail)
+                    throw e;
+            }
+        }
+    }
+    onFile(_locale, file) {
+        return file.default ?? false;
     }
-    callback = (_locale, file) => file;
 }
 exports.LangsHandler = LangsHandler;

package/lib/structures/AutoModerationRule.d.ts

@@ -1,15 +1,15 @@
-import type { APIAutoModerationRule, RESTPatchAPIAutoModerationRuleJSONBody, RESTPostAPIAutoModerationRuleJSONBody } from 'discord-api-types/v10';
 import type { UsingClient } from '../commands';
-import { type MethodContext, type ObjectToLower } from '../common';
+import type { MethodContext, ObjectToLower } from '../common';
+import type { APIAutoModerationRule, RESTPatchAPIAutoModerationRuleJSONBody, RESTPostAPIAutoModerationRuleJSONBody } from '../types';
 import { DiscordBase } from './extra/DiscordBase';
 export interface AutoModerationRule extends ObjectToLower<APIAutoModerationRule> {
 }
 export declare class AutoModerationRule extends DiscordBase<APIAutoModerationRule> {
     constructor(client: UsingClient, data: APIAutoModerationRule);
     fetchCreator(force?: boolean): Promise<import("./GuildMember").GuildMember>;
-    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
+    guild(force?: boolean): Promise<import("./Guild").Guild<"api">>;
     fetch(): Promise<AutoModerationRule>;
-    edit(body: ObjectToLower<RESTPatchAPIAutoModerationRuleJSONBody>, reason?: string): Promise<AutoModerationRule>;
+    edit(body: RESTPatchAPIAutoModerationRuleJSONBody, reason?: string): Promise<AutoModerationRule>;
     delete(reason?: string): Promise<never>;
     static methods({ client, guildId }: MethodContext<{
         guildId: string;

package/lib/structures/AutoModerationRule.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoModerationRule = void 0;
-const common_1 = require("../common");
 const DiscordBase_1 = require("./extra/DiscordBase");
 class AutoModerationRule extends DiscordBase_1.DiscordBase {
     constructor(client, data) {
@@ -28,7 +27,7 @@ class AutoModerationRule extends DiscordBase_1.DiscordBase {
             create: (body) => client.guilds.moderation.create(guildId, body),
             delete: (ruleId, reason) => client.guilds.moderation.delete(guildId, ruleId, reason),
             fetch: (ruleId) => client.guilds.moderation.fetch(guildId, ruleId),
-            edit: (ruleId, body, reason) => client.guilds.moderation.edit(guildId, ruleId, (0, common_1.toCamelCase)(body), reason),
+            edit: (ruleId, body, reason) => client.guilds.moderation.edit(guildId, ruleId, body, reason),
         };
     }
 }

package/lib/structures/ClientUser.d.ts

@@ -1,5 +1,5 @@
-import type { GatewayReadyDispatchData, RESTPatchAPICurrentUserJSONBody } from 'discord-api-types/v10';
 import type { UsingClient } from '../commands';
+import type { GatewayReadyDispatchData, RESTPatchAPICurrentUserJSONBody } from '../types';
 import { User } from './User';
 export declare class ClientUser extends User {
     application: GatewayReadyDispatchData['application'];

package/lib/structures/Entitlement.d.ts

@@ -0,0 +1,10 @@
+import type { ObjectToLower } from '../common';
+import type { APIEntitlement } from '../types';
+import { DiscordBase } from './extra/DiscordBase';
+export interface Entitlement extends ObjectToLower<APIEntitlement> {
+}
+export declare class Entitlement extends DiscordBase<APIEntitlement> {
+    get startsAtTimestamp(): number | null;
+    get endsAtTimestamp(): number | null;
+    consume(): Promise<never>;
+}

package/lib/structures/Entitlement.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entitlement = void 0;
+const DiscordBase_1 = require("./extra/DiscordBase");
+class Entitlement extends DiscordBase_1.DiscordBase {
+    get startsAtTimestamp() {
+        return this.startsAt ? Date.parse(this.startsAt) : null;
+    }
+    get endsAtTimestamp() {
+        return this.endsAt ? Date.parse(this.endsAt) : null;
+    }
+    consume() {
+        return this.client.applications.consumeEntitlement(this.applicationId, this.id);
+    }
+}
+exports.Entitlement = Entitlement;

package/lib/structures/Guild.d.ts

@@ -1,4 +1,3 @@
-import type { APIGuild, GatewayGuildCreateDispatchData } from 'discord-api-types/v10';
 import type { UsingClient } from '../commands';
 import type { ObjectToLower, StructPropState, StructStates, ToClass } from '../common/types/util';
 import { AutoModerationRule } from './AutoModerationRule';
@@ -10,9 +9,10 @@ import { Sticker } from './Sticker';
 import { BaseGuild } from './extra/BaseGuild';
 import type { DiscordBase } from './extra/DiscordBase';
 import { GuildBan } from './GuildBan';
+import type { APIGuild, GatewayGuildCreateDispatchData, RESTPatchAPIGuildJSONBody } from '../types';
 export interface Guild extends ObjectToLower<Omit<APIGuild, 'stickers' | 'emojis' | 'roles'>>, DiscordBase {
 }
-declare const Guild_base: ToClass<Omit<BaseGuild, "name" | "id" | "description" | "icon" | "splash" | "banner" | "features" | "welcomeScreen" | "verificationLevel" | "vanityUrlCode">, Guild<"api">>;
+declare const Guild_base: ToClass<Omit<BaseGuild, "id" | "name" | "description" | "icon" | "splash" | "banner" | "features" | "welcomeScreen" | "verificationLevel" | "vanityUrlCode">, Guild<"api">>;
 export declare class Guild<State extends StructStates = 'api'> extends Guild_base {
     joinedAt: StructPropState<number, State, 'create'>;
     memberCount: StructPropState<number, State, 'create'>;
@@ -24,70 +24,69 @@ export declare class Guild<State extends StructStates = 'api'> extends Guild_bas
     };
     get maxStickers(): MaxStickers;
     get maxEmojis(): MaxEmojis;
-    fetchOwner(force?: boolean): Promise<null> | Promise<GuildMember>;
+    fetchOwner(force?: boolean): Promise<GuildMember | null>;
     templates: {
         fetch: (code: string) => Promise<GuildTemplate>;
         list: () => Promise<GuildTemplate[]>;
-        create: (body: import("discord-api-types/v10").RESTPostAPIGuildTemplatesJSONBody) => Promise<GuildTemplate>;
+        create: (body: import("../types").RESTPostAPIGuildTemplatesJSONBody) => Promise<GuildTemplate>;
         sync: (code: string) => Promise<GuildTemplate>;
-        edit: (code: string, body: import("discord-api-types/utils/internals").AddUndefinedToPossiblyUndefinedPropertiesOfInterface<Partial<import("discord-api-types/v10").RESTPostAPIGuildTemplatesJSONBody>>) => Promise<GuildTemplate>;
+        edit: (code: string, body: import("../types").RESTPatchAPIGuildTemplateJSONBody) => Promise<GuildTemplate>;
         delete: (code: string) => Promise<GuildTemplate>;
     };
     stickers: {
         list: () => Promise<Sticker[]>;
-        create: (payload: import("./Sticker").CreateStickerBodyRequest, reason?: string | undefined) => Promise<Sticker>;
-        edit: (stickerId: string, body: import("discord-api-types/v10").RESTPatchAPIGuildStickerJSONBody, reason?: string | undefined) => Promise<Sticker>;
+        create: (payload: import("./Sticker").CreateStickerBodyRequest, reason?: string) => Promise<Sticker>;
+        edit: (stickerId: string, body: import("../types").RESTPatchAPIGuildStickerJSONBody, reason?: string) => Promise<Sticker>;
         fetch: (stickerId: string, force?: boolean) => Promise<Sticker>;
-        delete: (stickerId: string, reason?: string | undefined) => Promise<void>;
+        delete: (stickerId: string, reason?: string) => Promise<void>;
     };
     members: {
         resolve: (resolve: import("../common").GuildMemberResolvable) => Promise<GuildMember | undefined>;
-        search: (query?: import("discord-api-types/v10").RESTGetAPIGuildMembersSearchQuery | undefined) => Promise<GuildMember[]>;
-        unban: (id: string, body?: import("discord-api-types/v10").RESTPutAPIGuildBanJSONBody | undefined, reason?: string | undefined) => Promise<void>;
-        ban: (id: string, body?: import("discord-api-types/v10").RESTPutAPIGuildBanJSONBody | undefined, reason?: string | undefined) => Promise<void>;
-        kick: (id: string, reason?: string | undefined) => Promise<void>;
-        edit: (id: string, body: import("discord-api-types/v10").RESTPatchAPIGuildMemberJSONBody, reason?: string | undefined) => Promise<GuildMember>;
-        add: (id: string, body: import("discord-api-types/v10").RESTPutAPIGuildMemberJSONBody) => Promise<GuildMember | undefined>;
+        search: (query?: import("../types").RESTGetAPIGuildMembersSearchQuery) => Promise<GuildMember[]>;
+        unban: (id: string, body?: import("../types").RESTPutAPIGuildBanJSONBody, reason?: string) => Promise<void>;
+        ban: (id: string, body?: import("../types").RESTPutAPIGuildBanJSONBody, reason?: string) => Promise<void>;
+        kick: (id: string, reason?: string) => Promise<void>;
+        edit: (id: string, body: import("../types").RESTPatchAPIGuildMemberJSONBody, reason?: string) => Promise<GuildMember>;
+        add: (id: string, body: import("../types").RESTPutAPIGuildMemberJSONBody) => Promise<GuildMember | undefined>;
         fetch: (memberId: string, force?: boolean) => Promise<GuildMember>;
-        list: (query?: import("discord-api-types/v10").RESTGetAPIGuildMembersQuery | undefined, force?: boolean) => Promise<GuildMember[]>;
+        list: (query?: import("../types").RESTGetAPIGuildMembersQuery, force?: boolean) => Promise<GuildMember[]>;
     };
     moderationRules: {
         list: () => Promise<AutoModerationRule[]>;
-        create: (body: import("discord-api-types/v10").RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRule>;
-        delete: (ruleId: string, reason?: string | undefined) => Promise<never>;
+        create: (body: import("../types").RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRule>;
+        delete: (ruleId: string, reason?: string) => Promise<never>;
         fetch: (ruleId: string) => Promise<AutoModerationRule>;
-        edit: (ruleId: string, body: import("discord-api-types/v10").RESTPatchAPIAutoModerationRuleJSONBody, reason?: string | undefined) => Promise<AutoModerationRule>;
+        edit: (ruleId: string, body: import("../types").RESTPatchAPIAutoModerationRuleJSONBody, reason?: string) => Promise<AutoModerationRule>;
     };
     roles: {
-        create: (body: import("discord-api-types/v10").RESTPostAPIGuildRoleJSONBody) => Promise<GuildRole>;
+        create: (body: import("../types").RESTPostAPIGuildRoleJSONBody) => Promise<GuildRole>;
         list: (force?: boolean) => Promise<GuildRole[]>;
-        edit: (roleId: string, body: import("discord-api-types/v10").RESTPatchAPIGuildRoleJSONBody, reason?: string | undefined) => Promise<GuildRole>;
-        delete: (roleId: string, reason?: string | undefined) => Promise<GuildRole>;
-        editPositions: (body: import("discord-api-types/v10").RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
+        edit: (roleId: string, body: import("../types").RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<GuildRole>;
+        delete: (roleId: string, reason?: string) => Promise<GuildRole>;
+        editPositions: (body: import("../types").RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
     };
     channels: {
         list: (force?: boolean) => Promise<import("./channels").AllChannels[]>;
         fetch: (id: string, force?: boolean) => Promise<import("./channels").AllChannels>;
-        create: (body: import("discord-api-types/v10").RESTPostAPIGuildChannelJSONBody) => Promise<import("./channels").AllChannels>;
-        delete: (id: string, reason?: string | undefined) => Promise<import("./channels").AllChannels>;
-        edit: (id: string, body: import("discord-api-types/v10").RESTPatchAPIChannelJSONBody, reason?: string | undefined) => Promise<import("./channels").AllChannels>;
-        editPositions: (body: import("discord-api-types/v10").RESTPatchAPIGuildChannelPositionsJSONBody) => Promise<never>;
+        create: (body: import("../types").RESTPostAPIGuildChannelJSONBody) => Promise<import("./channels").AllChannels>;
+        delete: (id: string, reason?: string) => Promise<import("./channels").AllChannels>;
+        edit: (id: string, body: import("../types").RESTPatchAPIChannelJSONBody, reason?: string) => Promise<import("./channels").AllChannels>;
+        editPositions: (body: import("../types").RESTPatchAPIGuildChannelPositionsJSONBody) => Promise<never>;
     };
     emojis: {
-        edit: (emojiId: string, body: import("discord-api-types/v10").RESTPatchAPIGuildEmojiJSONBody, reason?: string | undefined) => Promise<GuildEmoji>;
-        create: (body: Omit<import("discord-api-types/v10").RESTPostAPIGuildEmojiJSONBody, "image"> & {
-            image: import("../common").ImageResolvable;
-        }) => Promise<GuildEmoji>;
+        edit: (emojiId: string, body: import("../types").RESTPatchAPIGuildEmojiJSONBody, reason?: string) => Promise<GuildEmoji>;
+        create: (body: Parameters<import("../common").EmojiShorter["create"]>[1]) => Promise<GuildEmoji>;
         fetch: (emojiId: string, force?: boolean) => Promise<GuildEmoji>;
         list: (force?: boolean) => Promise<GuildEmoji[]>;
     };
     bans: {
         fetch: (userId: string, force?: boolean) => Promise<GuildBan>;
-        list: (query?: import("discord-api-types/v10").RESTGetAPIGuildBansQuery | undefined, force?: boolean) => Promise<GuildBan[]>;
-        create: (memberId: string, body?: import("discord-api-types/v10").RESTPutAPIGuildBanJSONBody | undefined, reason?: string | undefined) => Promise<void>;
-        remove: (memberId: string, reason?: string | undefined) => Promise<void>;
-        bulkCreate: (body: import("discord-api-types/v10").RESTPostAPIGuildBulkBanJSONBody, reason?: string | undefined) => Promise<import("discord-api-types/v10").RESTPostAPIGuildBulkBanResult>;
+        list: (query?: import("../types").RESTGetAPIGuildBansQuery, force?: boolean) => Promise<GuildBan[]>;
+        create: (memberId: string, body?: Parameters<import("../common/shorters/bans").BanShorter["create"]>[2], reason?: string) => Promise<void>;
+        remove: (memberId: string, reason?: string) => Promise<void>;
+        bulkCreate: (body: Parameters<import("../common/shorters/bans").BanShorter["bulkCreate"]>[1], reason?: string) => Promise<import("../types").RESTPostAPIGuildBulkBanResult>;
     };
+    edit(body: RESTPatchAPIGuildJSONBody, reason?: string): Promise<Guild<"api">>;
 }
 /** Maximun custom guild emojis per level */
 export type MaxEmojis = 50 | 100 | 150 | 250;

package/lib/structures/Guild.js

@@ -49,10 +49,10 @@ class Guild extends BaseGuild_1.BaseGuild {
                 return 50;
         }
     }
-    fetchOwner(force = false) {
+    async fetchOwner(force = false) {
         // For no reason, discord has some guilds without owner... 🤓
         if (!this.ownerId) {
-            return Promise.resolve(null);
+            return null;
         }
         return this.members.fetch(this.ownerId, force);
     }
@@ -64,5 +64,8 @@ class Guild extends BaseGuild_1.BaseGuild {
     channels = channels_1.BaseChannel.allMethods({ client: this.client, guildId: this.id });
     emojis = GuildEmoji_1.GuildEmoji.methods({ client: this.client, guildId: this.id });
     bans = GuildBan_1.GuildBan.methods({ client: this.client, guildId: this.id });
+    edit(body, reason) {
+        return this.client.guilds.edit(this.id, body, reason);
+    }
 }
 exports.Guild = Guild;

package/lib/structures/GuildBan.d.ts

@@ -1,8 +1,8 @@
-import type { APIBan, RESTGetAPIGuildBansQuery } from 'discord-api-types/v10';
 import type { UsingClient } from '../commands';
-import type { MethodContext, ObjectToLower } from '../common';
+import { type MethodContext, type ObjectToLower } from '../common';
 import { DiscordBase } from './extra/DiscordBase';
 import type { BanShorter } from '../common/shorters/bans';
+import type { APIBan, RESTGetAPIGuildBansQuery } from '../types';
 export interface GuildBan extends DiscordBase, ObjectToLower<Omit<APIBan, 'id'>> {
 }
 export declare class GuildBan extends DiscordBase {
@@ -10,16 +10,16 @@ export declare class GuildBan extends DiscordBase {
     constructor(client: UsingClient, data: APIBan, guildId: string);
     create(body?: Parameters<BanShorter['create']>[2], reason?: string): Promise<void>;
     remove(reason?: string): Promise<void>;
-    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
+    guild(force?: boolean): Promise<import("./Guild").Guild<"api">>;
     fetch(force?: boolean): Promise<GuildBan>;
-    toString(): string;
+    toString(): `<@${string}>`;
     static methods({ client, guildId }: MethodContext<{
         guildId: string;
     }>): {
         fetch: (userId: string, force?: boolean) => Promise<GuildBan>;
         list: (query?: RESTGetAPIGuildBansQuery, force?: boolean) => Promise<GuildBan[]>;
-        create: (memberId: string, body?: Parameters<BanShorter['create']>[2], reason?: string) => Promise<void>;
+        create: (memberId: string, body?: Parameters<BanShorter["create"]>[2], reason?: string) => Promise<void>;
         remove: (memberId: string, reason?: string) => Promise<void>;
-        bulkCreate: (body: Parameters<BanShorter['bulkCreate']>[1], reason?: string) => Promise<import("discord-api-types/v10").RESTPostAPIGuildBulkBanResult>;
+        bulkCreate: (body: Parameters<BanShorter["bulkCreate"]>[1], reason?: string) => Promise<import("../types").RESTPostAPIGuildBulkBanResult>;
     };
 }

package/lib/structures/GuildBan.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GuildBan = void 0;
+const common_1 = require("../common");
 const DiscordBase_1 = require("./extra/DiscordBase");
 class GuildBan extends DiscordBase_1.DiscordBase {
     guildId;
@@ -21,7 +22,7 @@ class GuildBan extends DiscordBase_1.DiscordBase {
         return this.client.bans.fetch(this.guildId, this.id, force);
     }
     toString() {
-        return `<@${this.id}>`;
+        return common_1.Formatter.userMention(this.id);
     }
     static methods({ client, guildId }) {
         return {

package/lib/structures/GuildEmoji.d.ts

@@ -1,14 +1,14 @@
-import type { APIEmoji, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildEmojiJSONBody } from 'discord-api-types/v10';
 import type { BaseCDNUrlOptions } from '../api';
 import type { UsingClient } from '../commands';
-import type { EmojiShorter, MethodContext, ObjectToLower } from '../common';
+import { type EmojiShorter, type MethodContext, type ObjectToLower } from '../common';
+import type { APIEmoji, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildEmojiJSONBody } from '../types';
 import { DiscordBase } from './extra/DiscordBase';
 export interface GuildEmoji extends DiscordBase, ObjectToLower<Omit<APIEmoji, 'id'>> {
 }
 export declare class GuildEmoji extends DiscordBase {
     readonly guildId: string;
     constructor(client: UsingClient, data: APIEmoji, guildId: string);
-    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
+    guild(force?: boolean): Promise<import("./Guild").Guild<"api"> | undefined>;
     edit(body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<GuildEmoji>;
     delete(reason?: string): Promise<void>;
     fetch(force?: boolean): Promise<GuildEmoji>;
@@ -23,7 +23,7 @@ export declare class GuildEmoji extends DiscordBase {
         guildId: string;
     }>): {
         edit: (emojiId: string, body: RESTPatchAPIGuildEmojiJSONBody, reason?: string) => Promise<GuildEmoji>;
-        create: (body: Parameters<EmojiShorter['create']>[1]) => Promise<GuildEmoji>;
+        create: (body: Parameters<EmojiShorter["create"]>[1]) => Promise<GuildEmoji>;
         fetch: (emojiId: string, force?: boolean) => Promise<GuildEmoji>;
         list: (force?: boolean) => Promise<GuildEmoji[]>;
     };

package/lib/structures/GuildEmoji.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GuildEmoji = void 0;
+const common_1 = require("../common");
 const DiscordBase_1 = require("./extra/DiscordBase");
 class GuildEmoji extends DiscordBase_1.DiscordBase {
     guildId;
@@ -8,7 +9,7 @@ class GuildEmoji extends DiscordBase_1.DiscordBase {
         super(client, { ...data, id: data.id });
         this.guildId = guildId;
     }
-    guild(force = false) {
+    async guild(force = false) {
         if (!this.guildId)
             return;
         return this.client.guilds.fetch(this.guildId, force);
@@ -26,7 +27,7 @@ class GuildEmoji extends DiscordBase_1.DiscordBase {
         return this.rest.cdn.emojis(this.id).get(options);
     }
     toString() {
-        return `<${this.animated ? 'a' : ''}:${this.name}:${this.id}>`;
+        return common_1.Formatter.emojiMention(this.id, this.name, this.animated);
     }
     toJSON() {
         return {

package/lib/structures/GuildMember.d.ts

@@ -1,15 +1,10 @@
 import { DiscordBase } from './extra/DiscordBase';
-export type GuildMemberData = APIGuildMember | GatewayGuildMemberUpdateDispatchData | GatewayGuildMemberAddDispatchData | APIInteractionDataResolvedGuildMember;
-import type { APIGuildMember, APIInteractionDataResolvedGuildMember, APIUser, GatewayGuildMemberAddDispatchData, GatewayGuildMemberUpdateDispatchData, RESTGetAPIGuildMembersQuery, RESTGetAPIGuildMembersSearchQuery, RESTPatchAPIGuildMemberJSONBody, RESTPutAPIGuildBanJSONBody, RESTPutAPIGuildMemberJSONBody } from 'discord-api-types/v10';
+export type GuildMemberData = APIGuildMember | Omit<APIGuildMember, 'user'> | GatewayGuildMemberUpdateDispatchData | GatewayGuildMemberAddDispatchData | APIInteractionDataResolvedGuildMember;
+import type { APIGuildMember, GatewayGuildMemberUpdateDispatchData, GatewayGuildMemberAddDispatchData, APIInteractionDataResolvedGuildMember, RESTPutAPIGuildBanJSONBody, RESTPatchAPIGuildMemberJSONBody, RESTGetAPIGuildMembersSearchQuery, RESTPutAPIGuildMemberJSONBody, RESTGetAPIGuildMembersQuery, APIUser } from '../types';
 import type { UsingClient } from '../commands';
-import type { MakeRequired, MessageCreateBodyRequest, ObjectToLower, ToClass } from '../common';
-import type { ImageOptions, MethodContext } from '../common/types/options';
-import type { GuildMemberResolvable } from '../common/types/resolvables';
-import { User } from './User';
 import { PermissionsBitField } from './extra/Permissions';
-export type GatewayGuildMemberAddDispatchDataFixed<Pending extends boolean> = Pending extends true ? Omit<GatewayGuildMemberAddDispatchData, 'user'> & {
-    id: string;
-} : MakeRequired<GatewayGuildMemberAddDispatchData, 'user'>;
+import { type MessageCreateBodyRequest, type ObjectToLower, type ToClass, type ImageOptions, type MethodContext, type GuildMemberResolvable } from '../common';
+import { type UserStructure } from '../client/transformers';
 export interface BaseGuildMember extends DiscordBase, ObjectToLower<Omit<APIGuildMember, 'user' | 'roles'>> {
 }
 export declare class BaseGuildMember extends DiscordBase {
@@ -21,18 +16,21 @@ export declare class BaseGuildMember extends DiscordBase {
     constructor(client: UsingClient, data: GuildMemberData, id: string, 
     /** the choosen guild id */
     guildId: string);
-    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
+    guild(force?: boolean): Promise<import("./Guild").Guild<"api">>;
     fetch(force?: boolean): Promise<GuildMember>;
     ban(body?: RESTPutAPIGuildBanJSONBody, reason?: string): Promise<void>;
     kick(reason?: string): Promise<void>;
     edit(body: RESTPatchAPIGuildMemberJSONBody, reason?: string): Promise<GuildMember>;
-    presence(): import("..").ReturnCache<(Omit<import("discord-api-types/v10").GatewayPresenceUpdate, "user"> & {
+    presence(): import("..").ReturnCache<(Omit<import("../types").GatewayPresenceUpdate, "user"> & {
         id: string;
+        user_id: string;
     } & {
         guild_id: string;
     }) | undefined>;
-    voice(): import("..").ReturnCache<import("./VoiceState").VoiceState | undefined>;
-    toString(): string;
+    voice(force?: boolean): Promise<import("./VoiceState").VoiceState>;
+    toString(): `<@${string}>`;
+    timeout(time: null | number, reason?: string): Promise<GuildMember>;
+    get hasTimeout(): false | number;
     private patch;
     get roles(): {
         keys: string[];
@@ -66,9 +64,9 @@ export interface GuildMember extends ObjectToLower<Omit<APIGuildMember, 'user' |
 export declare class GuildMember extends BaseGuildMember {
     /** the choosen guild id */
     readonly guildId: string;
-    user: User;
+    user: UserStructure;
     private __me?;
-    constructor(client: UsingClient, data: GuildMemberData, user: APIUser | User, 
+    constructor(client: UsingClient, data: GuildMemberData, user: APIUser, 
     /** the choosen guild id */
     guildId: string);
     get tag(): string;
@@ -87,7 +85,12 @@ export declare class GuildMember extends BaseGuildMember {
     avatarURL(options?: ImageOptions & {
         exclude?: false;
     }): string;
-    bannerURL(options?: ImageOptions): string | undefined;
+    bannerURL(options: ImageOptions & {
+        exclude: true;
+    }): string | undefined | null;
+    bannerURL(options?: ImageOptions & {
+        exclude?: false;
+    }): string | undefined;
     fetchPermissions(force?: boolean): Promise<PermissionsBitField>;
     manageable(force?: boolean): Promise<boolean>;
     bannable(force?: boolean): Promise<boolean>;
@@ -108,7 +111,7 @@ declare const InteractionGuildMember_base: ToClass<Omit<GuildMember, "deaf" | "m
  */
 export declare class InteractionGuildMember extends InteractionGuildMember_base {
     permissions: PermissionsBitField;
-    constructor(client: UsingClient, data: APIInteractionDataResolvedGuildMember, user: APIUser | User, 
+    constructor(client: UsingClient, data: APIInteractionDataResolvedGuildMember, user: APIUser, 
     /** the choosen guild id */
     guildId: string);
 }