seyfert 2.1.1-dev-12404125172.0 → 2.1.1-dev-12450598903.0

package/lib/events/hooks/message.d.ts

@@ -2,13 +2,10 @@ import { type MessageStructure } from '../../client/transformers';
 import type { UsingClient } from '../../commands';
 import { type ObjectToLower, type OmitInsert } from '../../common';
 import type { GatewayMessageCreateDispatchData, GatewayMessageDeleteBulkDispatchData, GatewayMessageDeleteDispatchData, GatewayMessagePollVoteDispatchData, GatewayMessageReactionAddDispatchData, GatewayMessageReactionRemoveAllDispatchData, GatewayMessageReactionRemoveDispatchData, GatewayMessageReactionRemoveEmojiDispatchData, GatewayMessageUpdateDispatchData } from '../../types';
-export declare const MESSAGE_CREATE: (self: UsingClient, data: GatewayMessageCreateDispatchData) => import("../..").Message;
+export declare const MESSAGE_CREATE: (self: UsingClient, data: GatewayMessageCreateDispatchData) => MessageStructure;
 export declare const MESSAGE_DELETE: (self: UsingClient, data: GatewayMessageDeleteDispatchData) => Promise<MessageStructure | ObjectToLower<GatewayMessageDeleteDispatchData>>;
-export declare const MESSAGE_DELETE_BULK: (self: UsingClient, data: GatewayMessageDeleteBulkDispatchData) => Promise<{
-    messages: (string | import("../..").Message)[];
-    ids: import("../../types").Snowflake[];
-    channel_id: import("../../types").Snowflake;
-    guild_id?: import("../../types").Snowflake;
+export declare const MESSAGE_DELETE_BULK: (self: UsingClient, data: GatewayMessageDeleteBulkDispatchData) => Promise<GatewayMessageDeleteBulkDispatchData & {
+    messages: (MessageStructure | string)[];
 }>;
 export declare const MESSAGE_REACTION_ADD: (_self: UsingClient, data: GatewayMessageReactionAddDispatchData) => {
     type: import("../../types").ReactionType;

package/lib/events/hooks/soundboard.d.ts

@@ -1,121 +1,18 @@
+import { type UserStructure } from '../../client';
 import type { UsingClient } from '../../commands';
-import type { GatewayGuildSoundboardSoundCreateDispatchData, GatewayGuildSoundboardSoundDeleteDispatchData, GatewayGuildSoundboardSoundUpdateDispatchData, GatewayGuildSoundboardSoundsUpdateDispatchData, GatewaySoundboardSoundsDispatchData } from '../../types';
-export declare const GUILD_SOUNDBOARD_SOUND_CREATE: (self: UsingClient, data: GatewayGuildSoundboardSoundCreateDispatchData) => {
-    name: string;
-    soundId: string;
-    volume: number;
-    emojiId: string | null;
-    emojiName: string | null;
-    guildId?: string | undefined;
-    available: boolean;
-    user?: {
-        id: string;
-        username: string;
-        discriminator: string;
-        globalName: string | null;
-        avatar: string | null;
-        bot?: boolean | undefined;
-        system?: boolean | undefined;
-        mfaEnabled?: boolean | undefined;
-        banner?: string | null | undefined;
-        accentColor?: number | null | undefined;
-        locale?: string | undefined;
-        verified?: boolean | undefined;
-        email?: string | null | undefined;
-        flags?: import("../../types").UserFlags | undefined;
-        premiumType?: import("../../types").UserPremiumType | undefined;
-        publicFlags?: import("../../types").UserFlags | undefined;
-        avatarDecoration?: string | null | undefined;
-        avatarDecorationData?: import("../../types").APIAvatarDecorationData | null | undefined;
-    } | undefined;
-} | {
-    user: import("../..").User;
-    name: string;
-    soundId: string;
-    volume: number;
-    emojiId: string | null;
-    emojiName: string | null;
-    guildId?: string | undefined;
-    available: boolean;
-};
-export declare const GUILD_SOUNDBOARD_SOUND_UPDATE: (self: UsingClient, data: GatewayGuildSoundboardSoundUpdateDispatchData) => {
-    name: string;
-    soundId: string;
-    volume: number;
-    emojiId: string | null;
-    emojiName: string | null;
-    guildId?: string | undefined;
-    available: boolean;
-    user?: {
-        id: string;
-        username: string;
-        discriminator: string;
-        globalName: string | null;
-        avatar: string | null;
-        bot?: boolean | undefined;
-        system?: boolean | undefined;
-        mfaEnabled?: boolean | undefined;
-        banner?: string | null | undefined;
-        accentColor?: number | null | undefined;
-        locale?: string | undefined;
-        verified?: boolean | undefined;
-        email?: string | null | undefined;
-        flags?: import("../../types").UserFlags | undefined;
-        premiumType?: import("../../types").UserPremiumType | undefined;
-        publicFlags?: import("../../types").UserFlags | undefined;
-        avatarDecoration?: string | null | undefined;
-        avatarDecorationData?: import("../../types").APIAvatarDecorationData | null | undefined;
-    } | undefined;
-} | {
-    user: import("../..").User;
-    name: string;
-    soundId: string;
-    volume: number;
-    emojiId: string | null;
-    emojiName: string | null;
-    guildId?: string | undefined;
-    available: boolean;
-};
+import { type ObjectToLower } from '../../common';
+import type { APISoundBoard, GatewayGuildSoundboardSoundCreateDispatchData, GatewayGuildSoundboardSoundDeleteDispatchData, GatewayGuildSoundboardSoundUpdateDispatchData, GatewayGuildSoundboardSoundsUpdateDispatchData, GatewaySoundboardSoundsDispatchData } from '../../types';
+export declare const GUILD_SOUNDBOARD_SOUND_CREATE: (self: UsingClient, data: GatewayGuildSoundboardSoundCreateDispatchData) => (ObjectToLower<Omit<GatewayGuildSoundboardSoundCreateDispatchData, "user">> & {
+    user: UserStructure;
+}) | ObjectToLower<Omit<GatewayGuildSoundboardSoundCreateDispatchData, "user">>;
+export declare const GUILD_SOUNDBOARD_SOUND_UPDATE: (self: UsingClient, data: GatewayGuildSoundboardSoundUpdateDispatchData) => (ObjectToLower<Omit<GatewayGuildSoundboardSoundUpdateDispatchData, "user">> & {
+    user: UserStructure;
+}) | ObjectToLower<Omit<GatewayGuildSoundboardSoundUpdateDispatchData, "user">>;
 export declare const GUILD_SOUNDBOARD_SOUNDS_UPDATE: (self: UsingClient, data: GatewayGuildSoundboardSoundsUpdateDispatchData) => {
     guildId: string;
-    sounds: ({
-        name: string;
-        soundId: string;
-        volume: number;
-        emojiId: string | null;
-        emojiName: string | null;
-        guildId?: string | undefined;
-        available: boolean;
-        user?: {
-            id: string;
-            username: string;
-            discriminator: string;
-            globalName: string | null;
-            avatar: string | null;
-            bot?: boolean | undefined;
-            system?: boolean | undefined;
-            mfaEnabled?: boolean | undefined;
-            banner?: string | null | undefined;
-            accentColor?: number | null | undefined;
-            locale?: string | undefined;
-            verified?: boolean | undefined;
-            email?: string | null | undefined;
-            flags?: import("../../types").UserFlags | undefined;
-            premiumType?: import("../../types").UserPremiumType | undefined;
-            publicFlags?: import("../../types").UserFlags | undefined;
-            avatarDecoration?: string | null | undefined;
-            avatarDecorationData?: import("../../types").APIAvatarDecorationData | null | undefined;
-        } | undefined;
-    } | {
-        user: import("../..").User;
-        name: string;
-        soundId: string;
-        volume: number;
-        emojiId: string | null;
-        emojiName: string | null;
-        guildId?: string | undefined;
-        available: boolean;
-    })[];
+    sounds: ((ObjectToLower<Omit<APISoundBoard, "user">> & {
+        user: UserStructure;
+    }) | ObjectToLower<Omit<APISoundBoard, "user">>)[];
 };
 export declare const GUILD_SOUNDBOARD_SOUND_DELETE: (_: UsingClient, data: GatewayGuildSoundboardSoundDeleteDispatchData) => {
     soundId: string;

package/lib/events/hooks/thread.d.ts

@@ -1,13 +1,9 @@
 import { type ThreadChannelStructure } from '../../client/transformers';
 import type { UsingClient } from '../../commands';
+import { type ObjectToLower } from '../../common';
 import type { GatewayThreadCreateDispatchData, GatewayThreadDeleteDispatchData, GatewayThreadListSyncDispatchData, GatewayThreadMemberUpdateDispatchData, GatewayThreadMembersUpdateDispatchData, GatewayThreadUpdateDispatchData } from '../../types';
-export declare const THREAD_CREATE: (self: UsingClient, data: GatewayThreadCreateDispatchData) => import("../..").ThreadChannel;
-export declare const THREAD_DELETE: (self: UsingClient, data: GatewayThreadDeleteDispatchData) => Promise<import("../..").BaseChannel<import("../../types").ChannelType> | import("../..").DMChannel | import("../..").CategoryChannel | {
-    id: string;
-    guildId: string;
-    parentId: string;
-    type: import("../../types").ChannelType;
-}>;
+export declare const THREAD_CREATE: (self: UsingClient, data: GatewayThreadCreateDispatchData) => ThreadChannelStructure;
+export declare const THREAD_DELETE: (self: UsingClient, data: GatewayThreadDeleteDispatchData) => Promise<ThreadChannelStructure | ObjectToLower<GatewayThreadDeleteDispatchData>>;
 export declare const THREAD_LIST_SYNC: (_self: UsingClient, data: GatewayThreadListSyncDispatchData) => {
     guildId: string;
     channelIds?: string[] | undefined;

package/lib/events/hooks/typing.d.ts

@@ -1,51 +1,7 @@
+import { type GuildMemberStructure } from '../../client/transformers';
 import type { UsingClient } from '../../commands';
+import { type ObjectToLower } from '../../common';
 import type { GatewayTypingStartDispatchData } from '../../types';
-export declare const TYPING_START: (self: UsingClient, data: GatewayTypingStartDispatchData) => {
-    channelId: string;
-    guildId?: string | undefined;
-    userId: string;
-    timestamp: number;
-    member?: {
-        user: {
-            id: string;
-            username: string;
-            discriminator: string;
-            globalName: string | null;
-            avatar: string | null;
-            bot?: boolean | undefined;
-            system?: boolean | undefined;
-            mfaEnabled?: boolean | undefined;
-            banner?: string | null | undefined;
-            accentColor?: number | null | undefined;
-            locale?: string | undefined;
-            verified?: boolean | undefined;
-            email?: string | null | undefined;
-            flags?: import("../../types").UserFlags | undefined;
-            premiumType?: import("../../types").UserPremiumType | undefined;
-            publicFlags?: import("../../types").UserFlags | undefined;
-            avatarDecoration?: string | null | undefined;
-            avatarDecorationData?: {
-                asset: string;
-                skuId: string;
-            } | null | undefined;
-        };
-        nick?: string | null | undefined;
-        avatar?: string | null | undefined;
-        roles: string[];
-        joinedAt: string;
-        premiumSince?: string | null | undefined;
-        deaf: boolean;
-        mute: boolean;
-        flags: import("../../types").GuildMemberFlags;
-        pending?: boolean | undefined;
-        communicationDisabledUntil?: string | null | undefined;
-        avatarDecorationData?: import("../../types").APIAvatarDecorationData | null | undefined;
-        banner: string | null;
-    } | undefined;
-} | {
-    member: import("../..").GuildMember;
-    channelId: string;
-    guildId?: string | undefined;
-    userId: string;
-    timestamp: number;
-};
+export declare const TYPING_START: (self: UsingClient, data: GatewayTypingStartDispatchData) => (ObjectToLower<Omit<GatewayTypingStartDispatchData, "member">> & {
+    member: GuildMemberStructure;
+}) | ObjectToLower<Omit<GatewayTypingStartDispatchData, "member">>;

package/lib/structures/AutoModerationRule.d.ts

@@ -1,3 +1,4 @@
+import type { AutoModerationRuleStructure, GuildMemberStructure, GuildStructure } from '../client';
 import type { UsingClient } from '../commands';
 import type { MethodContext, ObjectToLower } from '../common';
 import type { APIAutoModerationRule, RESTPatchAPIAutoModerationRuleJSONBody, RESTPostAPIAutoModerationRuleJSONBody } from '../types';
@@ -6,18 +7,18 @@ 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<"api">>;
-    fetch(): Promise<AutoModerationRule>;
-    edit(body: RESTPatchAPIAutoModerationRuleJSONBody, reason?: string): Promise<AutoModerationRule>;
+    fetchCreator(force?: boolean): Promise<GuildMemberStructure>;
+    guild(force?: boolean): Promise<GuildStructure<'api'>>;
+    fetch(): Promise<AutoModerationRuleStructure>;
+    edit(body: RESTPatchAPIAutoModerationRuleJSONBody, reason?: string): Promise<AutoModerationRuleStructure>;
     delete(reason?: string): Promise<never>;
     static methods({ client, guildId }: MethodContext<{
         guildId: string;
     }>): {
-        list: () => Promise<AutoModerationRule[]>;
-        create: (body: RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRule>;
+        list: () => Promise<AutoModerationRuleStructure[]>;
+        create: (body: RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRuleStructure>;
         delete: (ruleId: string, reason?: string) => Promise<never>;
-        fetch: (ruleId: string) => Promise<AutoModerationRule>;
-        edit: (ruleId: string, body: RESTPatchAPIAutoModerationRuleJSONBody, reason?: string) => Promise<AutoModerationRule>;
+        fetch: (ruleId: string) => Promise<AutoModerationRuleStructure>;
+        edit: (ruleId: string, body: RESTPatchAPIAutoModerationRuleJSONBody, reason?: string) => Promise<AutoModerationRuleStructure>;
     };
 }

package/lib/structures/ClientUser.d.ts

@@ -1,3 +1,4 @@
+import type { ClientUserStructure } from '../client';
 import type { UsingClient } from '../commands';
 import type { GatewayReadyDispatchData, RESTPatchAPICurrentUserJSONBody } from '../types';
 import { User } from './User';
@@ -5,6 +6,6 @@ export declare class ClientUser extends User {
     application: GatewayReadyDispatchData['application'];
     bot: boolean;
     constructor(client: UsingClient, data: GatewayReadyDispatchData['user'], application: GatewayReadyDispatchData['application']);
-    fetch(): Promise<ClientUser>;
-    edit(body: RESTPatchAPICurrentUserJSONBody): Promise<ClientUser>;
+    fetch(): Promise<ClientUserStructure>;
+    edit(body: RESTPatchAPICurrentUserJSONBody): Promise<ClientUserStructure>;
 }

package/lib/structures/Guild.d.ts

@@ -1,13 +1,8 @@
+import type { GuildMemberStructure } from '../client';
 import type { UsingClient } from '../commands';
 import type { ObjectToLower, StructPropState, StructStates, ToClass } from '../common/types/util';
 import type { APIGuild, APIPartialGuild, GatewayGuildCreateDispatchData, RESTPatchAPIGuildJSONBody } from '../types';
-import { AutoModerationRule } from './AutoModerationRule';
-import { GuildBan } from './GuildBan';
-import { GuildEmoji } from './GuildEmoji';
 import { GuildMember } from './GuildMember';
-import { GuildRole } from './GuildRole';
-import { GuildTemplate } from './GuildTemplate';
-import { Sticker } from './Sticker';
 import { BaseGuild } from './extra/BaseGuild';
 import type { DiscordBase } from './extra/DiscordBase';
 export interface Guild extends ObjectToLower<Omit<APIGuild, 'stickers' | 'emojis' | 'roles'>>, DiscordBase {
@@ -20,52 +15,52 @@ export declare class Guild<State extends StructStates = 'api'> extends Guild_bas
     unavailable?: StructPropState<boolean, State, 'create'>;
     constructor(client: UsingClient, data: APIGuild | GatewayGuildCreateDispatchData);
     webhooks: {
-        list: () => Promise<import("./Webhook").Webhook[]>;
+        list: () => Promise<import("../client").WebhookStructure[]>;
     };
     get maxStickers(): MaxStickers;
     get maxEmojis(): MaxEmojis;
-    fetchOwner(force?: boolean): Promise<GuildMember | null>;
+    fetchOwner(force?: boolean): Promise<GuildMemberStructure | null>;
     templates: {
-        fetch: (code: string) => Promise<GuildTemplate>;
-        list: () => Promise<GuildTemplate[]>;
-        create: (body: import("../types").RESTPostAPIGuildTemplatesJSONBody) => Promise<GuildTemplate>;
-        sync: (code: string) => Promise<GuildTemplate>;
-        edit: (code: string, body: import("../types").RESTPatchAPIGuildTemplateJSONBody) => Promise<GuildTemplate>;
-        delete: (code: string) => Promise<GuildTemplate>;
+        fetch: (code: string) => Promise<import("../client").GuildTemplateStructure>;
+        list: () => Promise<import("../client").GuildTemplateStructure[]>;
+        create: (body: import("../types").RESTPostAPIGuildTemplatesJSONBody) => Promise<import("../client").GuildTemplateStructure>;
+        sync: (code: string) => Promise<import("../client").GuildTemplateStructure>;
+        edit: (code: string, body: import("../types").RESTPatchAPIGuildTemplateJSONBody) => Promise<import("../client").GuildTemplateStructure>;
+        delete: (code: string) => Promise<import("../client").GuildTemplateStructure>;
     };
     stickers: {
-        list: () => 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>;
+        list: () => Promise<import("../client").StickerStructure[]>;
+        create: (payload: import("./Sticker").CreateStickerBodyRequest, reason?: string) => Promise<import("../client").StickerStructure>;
+        edit: (stickerId: string, body: import("../types").RESTPatchAPIGuildStickerJSONBody, reason?: string) => Promise<import("../client").StickerStructure>;
+        fetch: (stickerId: string, force?: boolean) => Promise<import("../client").StickerStructure>;
         delete: (stickerId: string, reason?: string) => Promise<void>;
     };
     members: {
-        resolve: (resolve: import("../common").GuildMemberResolvable) => Promise<GuildMember | undefined>;
-        search: (query?: import("../types").RESTGetAPIGuildMembersSearchQuery) => Promise<GuildMember[]>;
+        resolve: (resolve: import("../common").GuildMemberResolvable) => Promise<GuildMemberStructure | undefined>;
+        search: (query?: import("../types").RESTGetAPIGuildMembersSearchQuery) => Promise<GuildMemberStructure[]>;
         unban: (id: string, reason?: string) => Promise<never>;
         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>;
+        add: (id: string, body: import("../types").RESTPutAPIGuildMemberJSONBody) => Promise<GuildMemberStructure | undefined>;
         addRole: (memberId: string, id: string) => Promise<never>;
         removeRole: (memberId: string, id: string) => Promise<never>;
-        fetch: (memberId: string, force?: boolean) => Promise<GuildMember>;
-        list: (query?: import("../types").RESTGetAPIGuildMembersQuery, force?: boolean) => Promise<GuildMember[]>;
+        fetch: (memberId: string, force?: boolean) => Promise<GuildMemberStructure>;
+        list: (query?: import("../types").RESTGetAPIGuildMembersQuery, force?: boolean) => Promise<GuildMemberStructure[]>;
     };
     moderationRules: {
-        list: () => Promise<AutoModerationRule[]>;
-        create: (body: import("../types").RESTPostAPIAutoModerationRuleJSONBody) => Promise<AutoModerationRule>;
+        list: () => Promise<import("../client").AutoModerationRuleStructure[]>;
+        create: (body: import("../types").RESTPostAPIAutoModerationRuleJSONBody) => Promise<import("../client").AutoModerationRuleStructure>;
         delete: (ruleId: string, reason?: string) => Promise<never>;
-        fetch: (ruleId: string) => Promise<AutoModerationRule>;
-        edit: (ruleId: string, body: import("../types").RESTPatchAPIAutoModerationRuleJSONBody, reason?: string) => Promise<AutoModerationRule>;
+        fetch: (ruleId: string) => Promise<import("../client").AutoModerationRuleStructure>;
+        edit: (ruleId: string, body: import("../types").RESTPatchAPIAutoModerationRuleJSONBody, reason?: string) => Promise<import("../client").AutoModerationRuleStructure>;
     };
     roles: {
-        create: (body: import("../types").RESTPostAPIGuildRoleJSONBody) => Promise<GuildRole>;
-        list: (force?: boolean) => 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[]>;
+        create: (body: import("../types").RESTPostAPIGuildRoleJSONBody) => Promise<import("../client").GuildRoleStructure>;
+        list: (force?: boolean) => Promise<import("../client").GuildRoleStructure[]>;
+        edit: (roleId: string, body: import("../types").RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<import("../client").GuildRoleStructure>;
+        delete: (roleId: string, reason?: string) => Promise<import("../client").GuildRoleStructure>;
+        editPositions: (body: import("../types").RESTPatchAPIGuildRolePositionsJSONBody) => Promise<import("../client").GuildRoleStructure[]>;
     };
     channels: {
         list: (force?: boolean) => Promise<import("./channels").AllChannels[]>;
@@ -76,14 +71,14 @@ export declare class Guild<State extends StructStates = 'api'> extends Guild_bas
         editPositions: (body: import("../types").RESTPatchAPIGuildChannelPositionsJSONBody) => Promise<never>;
     };
     emojis: {
-        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[]>;
+        edit: (emojiId: string, body: import("../types").RESTPatchAPIGuildEmojiJSONBody, reason?: string) => Promise<import("../client").GuildEmojiStructure>;
+        create: (body: Parameters<import("../common").EmojiShorter["create"]>[1]) => Promise<import("../client").GuildEmojiStructure>;
+        fetch: (emojiId: string, force?: boolean) => Promise<import("../client").GuildEmojiStructure>;
+        list: (force?: boolean) => Promise<import("../client").GuildEmojiStructure[]>;
     };
     bans: {
-        fetch: (userId: string, force?: boolean) => Promise<GuildBan>;
-        list: (query?: import("../types").RESTGetAPIGuildBansQuery, force?: boolean) => Promise<GuildBan[]>;
+        fetch: (userId: string, force?: boolean) => Promise<import("../client").GuildBanStructure>;
+        list: (query?: import("../types").RESTGetAPIGuildBansQuery, force?: boolean) => Promise<import("../client").GuildBanStructure[]>;
         create: (memberId: string, body?: Parameters<import("../common/shorters/bans").BanShorter["create"]>[2], reason?: string) => Promise<void>;
         remove: (memberId: string, reason?: string) => Promise<never>;
         bulkCreate: (body: Parameters<import("../common/shorters/bans").BanShorter["bulkCreate"]>[1], reason?: string) => Promise<import("../types").RESTPostAPIGuildBulkBanResult>;

package/lib/structures/GuildBan.d.ts

@@ -1,3 +1,4 @@
+import type { GuildBanStructure, GuildStructure } from '../client';
 import type { UsingClient } from '../commands';
 import { type MethodContext, type ObjectToLower } from '../common';
 import type { BanShorter } from '../common/shorters/bans';
@@ -10,14 +11,14 @@ 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<never>;
-    guild(force?: boolean): Promise<import("./Guild").Guild<"api">>;
-    fetch(force?: boolean): Promise<GuildBan>;
+    guild(force?: boolean): Promise<GuildStructure<'api'>>;
+    fetch(force?: boolean): Promise<GuildBanStructure>;
     toString(): `<@${string}>`;
     static methods({ client, guildId }: MethodContext<{
         guildId: string;
     }>): {
-        fetch: (userId: string, force?: boolean) => Promise<GuildBan>;
-        list: (query?: RESTGetAPIGuildBansQuery, force?: boolean) => Promise<GuildBan[]>;
+        fetch: (userId: string, force?: boolean) => Promise<GuildBanStructure>;
+        list: (query?: RESTGetAPIGuildBansQuery, force?: boolean) => Promise<GuildBanStructure[]>;
         create: (memberId: string, body?: Parameters<BanShorter["create"]>[2], reason?: string) => Promise<void>;
         remove: (memberId: string, reason?: string) => Promise<never>;
         bulkCreate: (body: Parameters<BanShorter["bulkCreate"]>[1], reason?: string) => Promise<import("../types").RESTPostAPIGuildBulkBanResult>;

package/lib/structures/GuildEmoji.d.ts

@@ -1,4 +1,5 @@
 import type { BaseCDNUrlOptions } from '../api';
+import type { GuildEmojiStructure, GuildStructure } from '../client';
 import type { UsingClient } from '../commands';
 import { type EmojiShorter, type MethodContext, type ObjectToLower } from '../common';
 import type { APIEmoji, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildEmojiJSONBody } from '../types';
@@ -8,10 +9,10 @@ export interface GuildEmoji extends DiscordBase, ObjectToLower<Omit<APIEmoji, 'i
 export declare class GuildEmoji extends DiscordBase {
     readonly guildId: string;
     constructor(client: UsingClient, data: APIEmoji, guildId: string);
-    guild(force?: boolean): Promise<import("./Guild").Guild<"api"> | undefined>;
-    edit(body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<GuildEmoji>;
+    guild(force?: boolean): Promise<GuildStructure<'api'> | undefined>;
+    edit(body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<GuildEmojiStructure>;
     delete(reason?: string): Promise<void>;
-    fetch(force?: boolean): Promise<GuildEmoji>;
+    fetch(force?: boolean): Promise<GuildEmojiStructure>;
     url(options?: BaseCDNUrlOptions): string;
     toString(): string;
     toJSON(): {
@@ -22,9 +23,9 @@ export declare class GuildEmoji extends DiscordBase {
     static methods({ client, guildId }: MethodContext<{
         guildId: string;
     }>): {
-        edit: (emojiId: string, body: RESTPatchAPIGuildEmojiJSONBody, reason?: string) => Promise<GuildEmoji>;
-        create: (body: Parameters<EmojiShorter["create"]>[1]) => Promise<GuildEmoji>;
-        fetch: (emojiId: string, force?: boolean) => Promise<GuildEmoji>;
-        list: (force?: boolean) => Promise<GuildEmoji[]>;
+        edit: (emojiId: string, body: RESTPatchAPIGuildEmojiJSONBody, reason?: string) => Promise<GuildEmojiStructure>;
+        create: (body: Parameters<EmojiShorter["create"]>[1]) => Promise<GuildEmojiStructure>;
+        fetch: (emojiId: string, force?: boolean) => Promise<GuildEmojiStructure>;
+        list: (force?: boolean) => Promise<GuildEmojiStructure[]>;
     };
 }

package/lib/structures/GuildMember.d.ts

@@ -1,9 +1,10 @@
 import { DiscordBase } from './extra/DiscordBase';
 export type GuildMemberData = APIGuildMember | Omit<APIGuildMember, 'user'> | GatewayGuildMemberUpdateDispatchData | GatewayGuildMemberAddDispatchData | APIInteractionDataResolvedGuildMember;
-import { type UserStructure } from '../client/transformers';
+import { type DMChannelStructure, type GuildMemberStructure, type GuildStructure, type MessageStructure, type UserStructure, type VoiceStateStructure } from '../client/transformers';
 import type { UsingClient } from '../commands';
 import { type GuildMemberResolvable, type ImageOptions, type MessageCreateBodyRequest, type MethodContext, type ObjectToLower, type ToClass } from '../common';
 import type { APIGuildMember, APIInteractionDataResolvedGuildMember, APIUser, GatewayGuildMemberAddDispatchData, GatewayGuildMemberUpdateDispatchData, RESTGetAPIGuildMembersQuery, RESTGetAPIGuildMembersSearchQuery, RESTPatchAPIGuildMemberJSONBody, RESTPutAPIGuildBanJSONBody, RESTPutAPIGuildMemberJSONBody } from '../types';
+import type { GuildRole } from './GuildRole';
 import { PermissionsBitField } from './extra/Permissions';
 export interface BaseGuildMember extends DiscordBase, ObjectToLower<Omit<APIGuildMember, 'user' | 'roles'>> {
 }
@@ -16,45 +17,45 @@ 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<"api">>;
-    fetch(force?: boolean): Promise<GuildMember>;
+    guild(force?: boolean): Promise<GuildStructure<'api'>>;
+    fetch(force?: boolean): Promise<GuildMemberStructure>;
     ban(body?: RESTPutAPIGuildBanJSONBody, reason?: string): Promise<void>;
     kick(reason?: string): Promise<void>;
-    edit(body: RESTPatchAPIGuildMemberJSONBody, reason?: string): Promise<GuildMember>;
+    edit(body: RESTPatchAPIGuildMemberJSONBody, reason?: string): Promise<GuildMemberStructure>;
     presence(): import("..").ReturnCache<(Omit<import("../types").GatewayPresenceUpdate, "user"> & {
         id: string;
         user_id: string;
     } & {
         guild_id: string;
     }) | undefined>;
-    voice(force?: boolean): Promise<import("./VoiceState").VoiceState>;
+    voice(force?: boolean): Promise<VoiceStateStructure>;
     toString(): `<@${string}>`;
-    timeout(time: null | number, reason?: string): Promise<GuildMember>;
+    timeout(time: null | number, reason?: string): Promise<GuildMemberStructure>;
     get hasTimeout(): false | number;
     private patch;
     get roles(): {
         keys: string[];
-        list: (force?: boolean) => Promise<import("./GuildRole").GuildRole[]>;
+        list: (force?: boolean) => Promise<GuildRole[]>;
         add: (id: string) => Promise<never>;
         remove: (id: string) => Promise<never>;
         permissions: (force?: boolean) => Promise<PermissionsBitField>;
-        sorted: (force?: boolean) => Promise<import("./GuildRole").GuildRole[]>;
-        highest: (force?: boolean) => Promise<import("./GuildRole").GuildRole>;
+        sorted: (force?: boolean) => Promise<GuildRole[]>;
+        highest: (force?: boolean) => Promise<GuildRole>;
     };
     static methods({ client, guildId }: MethodContext<{
         guildId: string;
     }>): {
-        resolve: (resolve: GuildMemberResolvable) => Promise<GuildMember | undefined>;
-        search: (query?: RESTGetAPIGuildMembersSearchQuery) => Promise<GuildMember[]>;
+        resolve: (resolve: GuildMemberResolvable) => Promise<GuildMemberStructure | undefined>;
+        search: (query?: RESTGetAPIGuildMembersSearchQuery) => Promise<GuildMemberStructure[]>;
         unban: (id: string, reason?: string) => Promise<never>;
         ban: (id: string, body?: RESTPutAPIGuildBanJSONBody, reason?: string) => Promise<void>;
         kick: (id: string, reason?: string) => Promise<void>;
         edit: (id: string, body: RESTPatchAPIGuildMemberJSONBody, reason?: string) => Promise<GuildMember>;
-        add: (id: string, body: RESTPutAPIGuildMemberJSONBody) => Promise<GuildMember | undefined>;
+        add: (id: string, body: RESTPutAPIGuildMemberJSONBody) => Promise<GuildMemberStructure | undefined>;
         addRole: (memberId: string, id: string) => Promise<never>;
         removeRole: (memberId: string, id: string) => Promise<never>;
-        fetch: (memberId: string, force?: boolean) => Promise<GuildMember>;
-        list: (query?: RESTGetAPIGuildMembersQuery, force?: boolean) => Promise<GuildMember[]>;
+        fetch: (memberId: string, force?: boolean) => Promise<GuildMemberStructure>;
+        list: (query?: RESTGetAPIGuildMembersQuery, force?: boolean) => Promise<GuildMemberStructure[]>;
     };
 }
 export interface GuildMember extends ObjectToLower<Omit<APIGuildMember, 'user' | 'roles'>> {
@@ -78,8 +79,8 @@ export declare class GuildMember extends BaseGuildMember {
     get globalName(): string | null;
     /** gets the nickname or the username */
     get displayName(): string;
-    dm(force?: boolean): Promise<import("./channels").DMChannel>;
-    write(body: MessageCreateBodyRequest): Promise<import("./Message").Message>;
+    dm(force?: boolean): Promise<DMChannelStructure>;
+    write(body: MessageCreateBodyRequest): Promise<MessageStructure>;
     defaultAvatarURL(): string;
     avatarURL(options: ImageOptions & {
         exclude: true;

package/lib/structures/GuildRole.d.ts

@@ -1,3 +1,4 @@
+import type { GuildRoleStructure, GuildStructure } from '../client';
 import type { UsingClient } from '../commands';
 import { type MethodContext, type ObjectToLower } from '../common';
 import type { APIRole, RESTPatchAPIGuildRoleJSONBody, RESTPatchAPIGuildRolePositionsJSONBody, RESTPostAPIGuildRoleJSONBody } from '../types';
@@ -9,18 +10,18 @@ export declare class GuildRole extends DiscordBase {
     readonly guildId: string;
     permissions: PermissionsBitField;
     constructor(client: UsingClient, data: APIRole, guildId: string);
-    guild(force?: boolean): Promise<import("./Guild").Guild<"api"> | undefined>;
-    fetch(force?: boolean): Promise<GuildRole>;
-    edit(body: RESTPatchAPIGuildRoleJSONBody): Promise<GuildRole>;
-    delete(reason?: string): Promise<GuildRole>;
+    guild(force?: boolean): Promise<GuildStructure<'api'> | undefined>;
+    fetch(force?: boolean): Promise<GuildRoleStructure>;
+    edit(body: RESTPatchAPIGuildRoleJSONBody): Promise<GuildRoleStructure>;
+    delete(reason?: string): Promise<GuildRoleStructure>;
     toString(): `<@&${string}>`;
     static methods(ctx: MethodContext<{
         guildId: string;
     }>): {
-        create: (body: RESTPostAPIGuildRoleJSONBody) => Promise<GuildRole>;
-        list: (force?: boolean) => Promise<GuildRole[]>;
-        edit: (roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<GuildRole>;
-        delete: (roleId: string, reason?: string) => Promise<GuildRole>;
-        editPositions: (body: RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
+        create: (body: RESTPostAPIGuildRoleJSONBody) => Promise<GuildRoleStructure>;
+        list: (force?: boolean) => Promise<GuildRoleStructure[]>;
+        edit: (roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<GuildRoleStructure>;
+        delete: (roleId: string, reason?: string) => Promise<GuildRoleStructure>;
+        editPositions: (body: RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRoleStructure[]>;
     };
 }

package/lib/structures/GuildTemplate.d.ts

@@ -1,3 +1,4 @@
+import type { GuildStructure, GuildTemplateStructure } from '../client';
 import type { UsingClient } from '../commands';
 import type { MethodContext, ObjectToLower } from '../common';
 import type { APITemplate, RESTPatchAPIGuildTemplateJSONBody, RESTPostAPIGuildTemplatesJSONBody } from '../types';
@@ -6,19 +7,19 @@ export interface GuildTemplate extends Base, ObjectToLower<APITemplate> {
 }
 export declare class GuildTemplate extends Base {
     constructor(client: UsingClient, data: APITemplate);
-    guild(force?: boolean): Promise<import("./Guild").Guild<"api">>;
-    fetch(): Promise<GuildTemplate>;
-    sync(): Promise<GuildTemplate>;
-    edit(body: RESTPatchAPIGuildTemplateJSONBody): Promise<GuildTemplate>;
-    delete(): Promise<GuildTemplate>;
+    guild(force?: boolean): Promise<GuildStructure<'api'>>;
+    fetch(): Promise<GuildTemplateStructure>;
+    sync(): Promise<GuildTemplateStructure>;
+    edit(body: RESTPatchAPIGuildTemplateJSONBody): Promise<GuildTemplateStructure>;
+    delete(): Promise<GuildTemplateStructure>;
     static methods(ctx: MethodContext<{
         guildId: string;
     }>): {
-        fetch: (code: string) => Promise<GuildTemplate>;
-        list: () => Promise<GuildTemplate[]>;
-        create: (body: RESTPostAPIGuildTemplatesJSONBody) => Promise<GuildTemplate>;
-        sync: (code: string) => Promise<GuildTemplate>;
-        edit: (code: string, body: RESTPatchAPIGuildTemplateJSONBody) => Promise<GuildTemplate>;
-        delete: (code: string) => Promise<GuildTemplate>;
+        fetch: (code: string) => Promise<GuildTemplateStructure>;
+        list: () => Promise<GuildTemplateStructure[]>;
+        create: (body: RESTPostAPIGuildTemplatesJSONBody) => Promise<GuildTemplateStructure>;
+        sync: (code: string) => Promise<GuildTemplateStructure>;
+        edit: (code: string, body: RESTPatchAPIGuildTemplateJSONBody) => Promise<GuildTemplateStructure>;
+        delete: (code: string) => Promise<GuildTemplateStructure>;
     };
 }