seyfert 0.1.0

package/lib/structures/Guild.d.ts

@@ -0,0 +1,86 @@
+import type { BaseClient } from '../client/base';
+import type { APIGuild, GatewayGuildCreateDispatchData, ObjectToLower } from '../common';
+import type { StructPropState, StructStates, ToClass } from '../common/types/util';
+import { GuildEmoji } from './GuildEmoji';
+import { GuildMember } from './GuildMember';
+import { GuildRole } from './GuildRole';
+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 {
+}
+declare const Guild_base: ToClass<Omit<BaseGuild, "name" | "id" | "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'>;
+    large: StructPropState<boolean, State, 'create'>;
+    unavailable?: StructPropState<boolean, State, 'create'>;
+    constructor(client: BaseClient, data: APIGuild | GatewayGuildCreateDispatchData);
+    webhooks: {
+        list: () => Promise<import("./Webhook").Webhook[]>;
+    };
+    get maxStickers(): MaxStickers;
+    get maxEmojis(): MaxEmojis;
+    fetchOwner(force?: boolean): Promise<GuildMember> | Promise<null>;
+    templates: {
+        fetch: (code: string) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        list: () => Promise<import("discord-api-types/rest/v10/template").RESTGetAPIGuildTemplatesResult>;
+        create: (body: import("discord-api-types/rest/v10/template").RESTPostAPIGuildTemplatesJSONBody) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        sync: (code: string) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        edit: (code: string, body: import("discord-api-types/utils/internals").AddUndefinedToPossiblyUndefinedPropertiesOfInterface<Partial<import("discord-api-types/rest/v10/template").RESTPostAPIGuildTemplatesJSONBody>>) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+        delete: (code: string) => Promise<import("discord-api-types/payloads/v10/template").APITemplate>;
+    };
+    stickers: {
+        list: () => Promise<Sticker[]>;
+        create: (payload: import("./Sticker").CreateStickerBodyRequest, reason?: string | undefined) => Promise<Sticker>;
+        edit: (stickerId: string, body: import("discord-api-types/rest/v10/sticker").RESTPatchAPIGuildStickerJSONBody, reason?: string | undefined) => Promise<Sticker>;
+        fetch: (stickerId: string, force?: boolean) => Promise<Sticker>;
+        delete: (stickerId: string, reason?: string | undefined) => Promise<void>;
+    };
+    members: {
+        resolve: (resolve: import("../common").GuildMemberResolvable) => Promise<GuildMember | undefined>;
+        search: (query?: import("discord-api-types/rest/v10/guild").RESTGetAPIGuildMembersSearchQuery | undefined) => Promise<GuildMember[]>;
+        unban: (id: string, body?: import("discord-api-types/rest/v10/guild").RESTPutAPIGuildBanJSONBody | undefined, reason?: string | undefined) => Promise<void>;
+        ban: (id: string, body?: import("discord-api-types/rest/v10/guild").RESTPutAPIGuildBanJSONBody | undefined, reason?: string | undefined) => Promise<void>;
+        kick: (id: string, reason?: string | undefined) => Promise<void>;
+        edit: (id: string, body: import("discord-api-types/rest/v10/guild").RESTPatchAPIGuildMemberJSONBody, reason?: string | undefined) => Promise<GuildMember>;
+        add: (id: string, body: import("discord-api-types/rest/v10/guild").RESTPutAPIGuildMemberJSONBody) => Promise<GuildMember | undefined>;
+        fetch: (memberId: string, force?: boolean) => Promise<GuildMember>;
+        list: (query?: import("discord-api-types/rest/v10/guild").RESTGetAPIGuildMembersQuery | undefined, force?: boolean) => Promise<GuildMember[]>;
+    };
+    moderationRules: {
+        list: () => Promise<import("discord-api-types/rest/v10/autoModeration").RESTGetAPIAutoModerationRulesResult>;
+        create: (body: import("discord-api-types/rest/v10/autoModeration").RESTPostAPIAutoModerationRuleJSONBody) => Promise<import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationRule>;
+        delete: (ruleId: string, reason?: string | undefined) => Promise<never>;
+        fetch: (ruleId: string) => Promise<import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationRule>;
+        edit: (ruleId: string, body: import("discord-api-types/rest/v10/autoModeration").RESTPatchAPIAutoModerationRuleJSONBody, reason?: string | undefined) => Promise<import("discord-api-types/payloads/v10/autoModeration").APIAutoModerationRule>;
+    };
+    roles: {
+        create: (body: import("discord-api-types/rest/v10/guild").RESTPostAPIGuildRoleJSONBody) => Promise<any>;
+        list: (force?: boolean) => Promise<GuildRole[]>;
+        edit: (roleId: string, body: import("discord-api-types/rest/v10/guild").RESTPatchAPIGuildRoleJSONBody, reason?: string | undefined) => Promise<any>;
+        delete: (roleId: string, reason?: string | undefined) => Promise<void | undefined>;
+        editPositions: (body: import("discord-api-types/rest/v10/guild").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/rest/v10/guild").RESTPostAPIGuildChannelJSONBody) => Promise<import("./channels").AllChannels>;
+        delete: (id: string, reason?: string | undefined) => Promise<import("./channels").AllChannels>;
+        edit: (id: string, body: import("discord-api-types/rest/v10/channel").RESTPatchAPIChannelJSONBody, reason?: string | undefined) => Promise<import("./channels").AllChannels>;
+        editPositions: (body: import("discord-api-types/rest/v10/guild").RESTPatchAPIGuildChannelPositionsJSONBody) => Promise<never>;
+    };
+    emojis: {
+        edit: (emojiId: string, body: import("discord-api-types/rest/v10/emoji").RESTPatchAPIGuildEmojiJSONBody, reason?: string | undefined) => Promise<GuildEmoji>;
+        create: (body: Omit<import("discord-api-types/rest/v10/emoji").RESTPostAPIGuildEmojiJSONBody, "image"> & {
+            image: import("../common").ImageResolvable;
+        }) => Promise<void>;
+        fetch: (emojiId: string, force?: boolean) => Promise<GuildEmoji>;
+        list: (force?: boolean) => Promise<GuildEmoji[]>;
+    };
+}
+/** Maximun custom guild emojis per level */
+export type MaxEmojis = 50 | 100 | 150 | 250;
+/** Maximun custom guild stickers per level */
+export type MaxStickers = 5 | 15 | 30 | 60;
+export {};

package/lib/structures/Guild.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guild = void 0;
+const AutoModerationRule_1 = require("./AutoModerationRule");
+const GuildEmoji_1 = require("./GuildEmoji");
+const GuildMember_1 = require("./GuildMember");
+const GuildRole_1 = require("./GuildRole");
+const GuildTemplate_1 = require("./GuildTemplate");
+const Sticker_1 = require("./Sticker");
+const channels_1 = require("./channels");
+const BaseGuild_1 = require("./extra/BaseGuild");
+class Guild extends BaseGuild_1.BaseGuild {
+    joinedAt;
+    memberCount;
+    large;
+    unavailable;
+    constructor(client, data) {
+        super(client, data);
+        if ('joined_at' in data) {
+            this.joinedAt = Number(data.joined_at);
+            this.memberCount = data.member_count;
+            this.large = data.large;
+            this.unavailable = data.unavailable;
+        }
+    }
+    webhooks = channels_1.WebhookGuildMethods.guild({ client: this.client, guildId: this.id });
+    get maxStickers() {
+        switch (this.premiumTier) {
+            case 1:
+                return 15;
+            case 2:
+                return 30;
+            case 3:
+                return 60;
+            default:
+                return 5;
+        }
+    }
+    get maxEmojis() {
+        switch (this.premiumTier) {
+            case 1:
+                return 100;
+            case 2:
+                return 150;
+            case 3:
+                return 250;
+            default:
+                return 50;
+        }
+    }
+    fetchOwner(force = false) {
+        // For no reason, discord has some guilds without owner... 🤓
+        if (!this.ownerId) {
+            return Promise.resolve(null);
+        }
+        return this.members.fetch(this.ownerId, force);
+    }
+    templates = GuildTemplate_1.GuildTemplate.methods({ client: this.client, guildId: this.id });
+    stickers = Sticker_1.Sticker.methods({ client: this.client, guildId: this.id });
+    members = GuildMember_1.GuildMember.methods({ client: this.client, guildId: this.id });
+    moderationRules = AutoModerationRule_1.AutoModerationRule.methods({ client: this.client, guildId: this.id });
+    roles = GuildRole_1.GuildRole.methods({ client: this.client, guildId: this.id });
+    channels = channels_1.BaseChannel.allMethods({ client: this.client, guildId: this.id });
+    emojis = GuildEmoji_1.GuildEmoji.methods({ client: this.client, guildId: this.id });
+}
+exports.Guild = Guild;

package/lib/structures/GuildEmoji.d.ts

@@ -0,0 +1,29 @@
+import type { BaseImageURLOptions } from '../api';
+import type { BaseClient } from '../client/base';
+import type { APIEmoji, GuildShorter, MethodContext, ObjectToLower, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildEmojiJSONBody } from '../common';
+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: BaseClient, data: APIEmoji, guildId: string);
+    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
+    edit(body: RESTPatchAPIChannelJSONBody, reason?: string): Promise<GuildEmoji>;
+    delete(reason?: string): Promise<void>;
+    fetch(force?: boolean): Promise<GuildEmoji>;
+    url(options?: BaseImageURLOptions): string;
+    toString(): string;
+    toJSON(): {
+        id: string;
+        name: string | null;
+        animated: boolean;
+    };
+    static methods({ client, guildId }: MethodContext<{
+        guildId: string;
+    }>): {
+        edit: (emojiId: string, body: RESTPatchAPIGuildEmojiJSONBody, reason?: string) => Promise<GuildEmoji>;
+        create: (body: Parameters<GuildShorter['emojis']['create']>[1]) => Promise<void>;
+        fetch: (emojiId: string, force?: boolean) => Promise<GuildEmoji>;
+        list: (force?: boolean) => Promise<GuildEmoji[]>;
+    };
+}

package/lib/structures/GuildEmoji.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildEmoji = void 0;
+const DiscordBase_1 = require("./extra/DiscordBase");
+class GuildEmoji extends DiscordBase_1.DiscordBase {
+    guildId;
+    constructor(client, data, guildId) {
+        super(client, { ...data, id: data.id });
+        this.guildId = guildId;
+    }
+    guild(force = false) {
+        if (!this.guildId)
+            return;
+        return this.client.guilds.fetch(this.guildId, force);
+    }
+    edit(body, reason) {
+        return this.client.guilds.emojis.edit(this.guildId, this.id, body, reason);
+    }
+    delete(reason) {
+        return this.client.guilds.emojis.delete(this.guildId, this.id, reason);
+    }
+    fetch(force = false) {
+        return this.client.guilds.emojis.fetch(this.guildId, this.id, force);
+    }
+    url(options) {
+        return this.rest.cdn.emoji(this.id, options);
+    }
+    toString() {
+        return `<${this.animated ? 'a' : ''}:${this.name}:${this.id}>`;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            animated: !!this.animated,
+        };
+    }
+    static methods({ client, guildId }) {
+        return {
+            edit: (emojiId, body, reason) => client.guilds.emojis.edit(guildId, emojiId, body, reason),
+            create: (body) => client.guilds.emojis.create(guildId, body),
+            fetch: (emojiId, force = false) => client.guilds.emojis.fetch(guildId, emojiId, force),
+            list: (force = false) => client.guilds.emojis.list(guildId, force),
+        };
+    }
+}
+exports.GuildEmoji = GuildEmoji;

package/lib/structures/GuildMember.d.ts

@@ -0,0 +1,92 @@
+import type { APIGuildMember, APIInteractionDataResolvedGuildMember, APIUser, GatewayGuildMemberAddDispatchData, GatewayGuildMemberUpdateDispatchData, MakeRequired, MessageCreateBodyRequest, ObjectToLower, RESTGetAPIGuildMembersQuery, RESTGetAPIGuildMembersSearchQuery, RESTPatchAPIGuildMemberJSONBody, RESTPutAPIGuildBanJSONBody, RESTPutAPIGuildMemberJSONBody, ToClass } from '../common';
+import { DiscordBase } from './extra/DiscordBase';
+export type GuildMemberData = APIGuildMember | GatewayGuildMemberUpdateDispatchData | GatewayGuildMemberAddDispatchData | APIInteractionDataResolvedGuildMember;
+import type { BaseClient } from '../client/base';
+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'>;
+export interface BaseGuildMember extends DiscordBase, ObjectToLower<Omit<APIGuildMember, 'user' | 'roles'>> {
+}
+export declare class BaseGuildMember extends DiscordBase {
+    /** the choosen guild id */
+    readonly guildId: string;
+    private _roles;
+    joinedTimestamp?: number;
+    communicationDisabledUntilTimestamp?: number | null;
+    constructor(client: BaseClient, data: GuildMemberData, id: string, 
+    /** the choosen guild id */
+    guildId: string);
+    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | 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>;
+    toString(): string;
+    private patch;
+    get roles(): {
+        values: readonly string[];
+        add: (id: string) => Promise<void>;
+        remove: (id: string) => Promise<void>;
+    };
+    static methods({ client, guildId }: MethodContext<{
+        guildId: string;
+    }>): {
+        resolve: (resolve: GuildMemberResolvable) => Promise<GuildMember | undefined>;
+        search: (query?: RESTGetAPIGuildMembersSearchQuery) => Promise<GuildMember[]>;
+        unban: (id: string, body?: RESTPutAPIGuildBanJSONBody, reason?: string) => Promise<void>;
+        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>;
+        fetch: (memberId: string, force?: boolean) => Promise<GuildMember>;
+        list: (query?: RESTGetAPIGuildMembersQuery, force?: boolean) => Promise<GuildMember[]>;
+    };
+}
+export interface GuildMember extends ObjectToLower<Omit<APIGuildMember, 'user' | 'roles'>> {
+}
+/**
+ * Represents a guild member
+ * @link https://discord.com/developers/docs/resources/guild#guild-member-object
+ */
+export declare class GuildMember extends BaseGuildMember {
+    /** the choosen guild id */
+    readonly guildId: string;
+    user: User;
+    constructor(client: BaseClient, data: GuildMemberData, user: APIUser | User, 
+    /** the choosen guild id */
+    guildId: string);
+    get tag(): string;
+    get bot(): boolean | undefined;
+    get name(): string;
+    get username(): string;
+    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>;
+    avatarURL(options?: ImageOptions): string;
+    dynamicAvatarURL(options?: ImageOptions): string;
+}
+export interface UnavailableMember {
+    pending: true;
+}
+export declare class UnavailableMember extends BaseGuildMember {
+}
+export interface InteractionGuildMember extends ObjectToLower<Omit<APIInteractionDataResolvedGuildMember, 'roles' | 'deaf' | 'mute' | 'permissions'>> {
+}
+declare const InteractionGuildMember_base: ToClass<Omit<GuildMember, "deaf" | "mute">, InteractionGuildMember>;
+/**
+ * Represents a guild member
+ * @link https://discord.com/developers/docs/resources/guild#guild-member-object
+ */
+export declare class InteractionGuildMember extends InteractionGuildMember_base {
+    permissions: PermissionsBitField;
+    constructor(client: BaseClient, data: APIInteractionDataResolvedGuildMember, user: APIUser | User, 
+    /** the choosen guild id */
+    guildId: string);
+}
+export {};

package/lib/structures/GuildMember.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionGuildMember = exports.UnavailableMember = exports.GuildMember = exports.BaseGuildMember = void 0;
+const DiscordBase_1 = require("./extra/DiscordBase");
+const User_1 = require("./User");
+const Permissions_1 = require("./extra/Permissions");
+class BaseGuildMember extends DiscordBase_1.DiscordBase {
+    guildId;
+    _roles;
+    joinedTimestamp;
+    communicationDisabledUntilTimestamp;
+    constructor(client, data, id, 
+    /** the choosen guild id */
+    guildId) {
+        const { roles, ...dataN } = data;
+        super(client, { ...dataN, id });
+        this.guildId = guildId;
+        this._roles = data.roles;
+        this.patch(data);
+    }
+    guild(force = false) {
+        return this.client.guilds.fetch(this.id, force);
+    }
+    fetch(force = false) {
+        return this.client.members.fetch(this.guildId, this.id, force);
+    }
+    ban(body, reason) {
+        return this.client.members.ban(this.guildId, this.id, body, reason);
+    }
+    kick(reason) {
+        return this.client.members.kick(this.guildId, this.id, reason);
+    }
+    edit(body, reason) {
+        return this.client.members.edit(this.guildId, this.id, body, reason);
+    }
+    toString() {
+        return `<@${this.id}>`;
+    }
+    patch(data) {
+        if ('joined_at' in data && data.joined_at) {
+            this.joinedTimestamp = Date.parse(data.joined_at);
+        }
+        if ('communication_disabled_until' in data) {
+            this.communicationDisabledUntilTimestamp = data.communication_disabled_until?.length
+                ? Date.parse(data.communication_disabled_until)
+                : null;
+        }
+    }
+    get roles() {
+        return {
+            values: Object.freeze(this._roles),
+            add: (id) => this.client.members.roles.add(this.guildId, this.id, id),
+            remove: (id) => this.client.members.roles.remove(this.guildId, this.id, id),
+        };
+    }
+    static methods({ client, guildId }) {
+        return {
+            resolve: (resolve) => client.members.resolve(guildId, resolve),
+            search: (query) => client.members.search(guildId, query),
+            unban: (id, body, reason) => client.members.unban(guildId, id, body, reason),
+            ban: (id, body, reason) => client.members.ban(guildId, id, body, reason),
+            kick: (id, reason) => client.members.kick(guildId, id, reason),
+            edit: (id, body, reason) => client.members.edit(guildId, id, body, reason),
+            add: (id, body) => client.members.add(guildId, id, body),
+            fetch: (memberId, force = false) => client.members.fetch(guildId, memberId, force),
+            list: (query, force = false) => client.members.list(guildId, query, force),
+        };
+    }
+}
+exports.BaseGuildMember = BaseGuildMember;
+/**
+ * Represents a guild member
+ * @link https://discord.com/developers/docs/resources/guild#guild-member-object
+ */
+class GuildMember extends BaseGuildMember {
+    guildId;
+    user;
+    constructor(client, data, user, 
+    /** the choosen guild id */
+    guildId) {
+        super(client, data, user.id, guildId);
+        this.guildId = guildId;
+        this.user = user instanceof User_1.User ? user : new User_1.User(client, user);
+    }
+    get tag() {
+        return this.user.tag;
+    }
+    get bot() {
+        return this.user.bot;
+    }
+    get name() {
+        return this.user.name;
+    }
+    get username() {
+        return this.user.username;
+    }
+    get globalName() {
+        return this.user.globalName;
+    }
+    /** gets the nickname or the username */
+    get displayName() {
+        return this.nick ?? this.globalName ?? this.username;
+    }
+    dm(force = false) {
+        return this.user.dm(force);
+    }
+    write(body) {
+        return this.user.write(body);
+    }
+    avatarURL(options) {
+        return this.user.avatarURL(options);
+    }
+    dynamicAvatarURL(options) {
+        if (!this.avatar) {
+            return this.user.avatarURL(options);
+        }
+        return this.rest.cdn.guildMemberAvatar(this.guildId, this.id, this.avatar, options);
+    }
+}
+exports.GuildMember = GuildMember;
+class UnavailableMember extends BaseGuildMember {
+}
+exports.UnavailableMember = UnavailableMember;
+/**
+ * Represents a guild member
+ * @link https://discord.com/developers/docs/resources/guild#guild-member-object
+ */
+class InteractionGuildMember extends GuildMember {
+    permissions;
+    constructor(client, data, user, 
+    /** the choosen guild id */
+    guildId) {
+        super(client, data, user, guildId);
+        this.permissions = new Permissions_1.PermissionsBitField(Number(data.permissions));
+    }
+}
+exports.InteractionGuildMember = InteractionGuildMember;

package/lib/structures/GuildPreview.d.ts

@@ -0,0 +1,10 @@
+import type { BaseClient } from '../client/base';
+import type { APIGuildPreview } from '../common';
+import { AnonymousGuild } from './AnonymousGuild';
+/**
+ * Represent Discord Guild Preview Object
+ * @link https://discord.com/developers/docs/resources/guild#guild-preview-object
+ */
+export declare class GuildPreview extends AnonymousGuild {
+    constructor(client: BaseClient, data: APIGuildPreview);
+}

package/lib/structures/GuildPreview.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildPreview = void 0;
+const AnonymousGuild_1 = require("./AnonymousGuild");
+/**
+ * Represent Discord Guild Preview Object
+ * @link https://discord.com/developers/docs/resources/guild#guild-preview-object
+ */
+class GuildPreview extends AnonymousGuild_1.AnonymousGuild {
+    constructor(client, data) {
+        super(client, data);
+    }
+}
+exports.GuildPreview = GuildPreview;

package/lib/structures/GuildRole.d.ts

@@ -0,0 +1,21 @@
+import type { BaseClient } from '../client/base';
+import type { APIRole, MethodContext, ObjectToLower, RESTPatchAPIGuildRoleJSONBody, RESTPatchAPIGuildRolePositionsJSONBody, RESTPostAPIGuildRoleJSONBody } from '../common';
+import { DiscordBase } from './extra/DiscordBase';
+export interface GuildRole extends DiscordBase, ObjectToLower<APIRole> {
+}
+export declare class GuildRole extends DiscordBase {
+    readonly guildId: string;
+    constructor(client: BaseClient, data: APIRole, guildId: string);
+    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api"> | undefined>;
+    edit(body: RESTPatchAPIGuildRoleJSONBody, reason?: string): Promise<any>;
+    delete(reason?: string): Promise<void | undefined>;
+    static methods(ctx: MethodContext<{
+        guildId: string;
+    }>): {
+        create: (body: RESTPostAPIGuildRoleJSONBody) => Promise<any>;
+        list: (force?: boolean) => Promise<GuildRole[]>;
+        edit: (roleId: string, body: RESTPatchAPIGuildRoleJSONBody, reason?: string) => Promise<any>;
+        delete: (roleId: string, reason?: string) => Promise<void | undefined>;
+        editPositions: (body: RESTPatchAPIGuildRolePositionsJSONBody) => Promise<GuildRole[]>;
+    };
+}

package/lib/structures/GuildRole.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildRole = void 0;
+const DiscordBase_1 = require("./extra/DiscordBase");
+class GuildRole extends DiscordBase_1.DiscordBase {
+    guildId;
+    constructor(client, data, guildId) {
+        super(client, data);
+        this.guildId = guildId;
+    }
+    async guild(force = false) {
+        if (!this.guildId)
+            return;
+        return this.client.guilds.fetch(this.guildId, force);
+    }
+    edit(body, reason) {
+        return this.client.roles.create(this.guildId, body, reason);
+    }
+    delete(reason) {
+        return this.client.roles.delete(this.guildId, this.id, reason);
+    }
+    static methods(ctx) {
+        return {
+            create: (body) => ctx.client.roles.create(ctx.guildId, body),
+            list: (force = false) => ctx.client.roles.list(ctx.guildId, force),
+            edit: (roleId, body, reason) => ctx.client.roles.edit(ctx.guildId, roleId, body, reason),
+            delete: (roleId, reason) => ctx.client.roles.delete(ctx.guildId, roleId, reason),
+            editPositions: (body) => ctx.client.roles.editPositions(ctx.guildId, body),
+        };
+    }
+}
+exports.GuildRole = GuildRole;

package/lib/structures/GuildTemplate.d.ts

@@ -0,0 +1,23 @@
+import type { BaseClient } from '../client/base';
+import type { APITemplate, MethodContext, ObjectToLower, RESTPatchAPIGuildTemplateJSONBody, RESTPostAPIGuildTemplatesJSONBody } from '../common';
+import { Base } from './extra/Base';
+export interface GuildTemplate extends Base, ObjectToLower<APITemplate> {
+}
+export declare class GuildTemplate extends Base {
+    constructor(client: BaseClient, data: APITemplate);
+    guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
+    fetch(): Promise<APITemplate>;
+    sync(): Promise<APITemplate>;
+    edit(body: RESTPatchAPIGuildTemplateJSONBody): Promise<APITemplate>;
+    delete(): Promise<APITemplate>;
+    static methods(ctx: MethodContext<{
+        guildId: string;
+    }>): {
+        fetch: (code: string) => Promise<APITemplate>;
+        list: () => Promise<import("discord-api-types/rest/v10/template").RESTGetAPIGuildTemplatesResult>;
+        create: (body: RESTPostAPIGuildTemplatesJSONBody) => Promise<APITemplate>;
+        sync: (code: string) => Promise<APITemplate>;
+        edit: (code: string, body: RESTPatchAPIGuildTemplateJSONBody) => Promise<APITemplate>;
+        delete: (code: string) => Promise<APITemplate>;
+    };
+}

package/lib/structures/GuildTemplate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildTemplate = void 0;
+const Base_1 = require("./extra/Base");
+class GuildTemplate extends Base_1.Base {
+    constructor(client, data) {
+        super(client);
+        this.__patchThis(data);
+    }
+    async guild(force = false) {
+        return this.client.guilds.fetch(this.sourceGuildId, force);
+    }
+    async fetch() {
+        return this.client.templates.fetch(this.sourceGuildId);
+    }
+    sync() {
+        return this.client.templates.sync(this.sourceGuildId, this.code);
+    }
+    edit(body) {
+        return this.client.templates.edit(this.sourceGuildId, this.code, body);
+    }
+    delete() {
+        return this.client.templates.delete(this.sourceGuildId, this.code);
+    }
+    static methods(ctx) {
+        return {
+            fetch: (code) => ctx.client.templates.fetch(code),
+            list: () => ctx.client.templates.list(ctx.guildId),
+            create: (body) => ctx.client.templates.create(ctx.guildId, body),
+            sync: (code) => ctx.client.templates.sync(ctx.guildId, code),
+            edit: (code, body) => ctx.client.templates.edit(ctx.guildId, code, body),
+            delete: (code) => ctx.client.templates.delete(ctx.guildId, code),
+        };
+    }
+}
+exports.GuildTemplate = GuildTemplate;