seyfert 0.1.0

package/lib/cache/index.js

@@ -0,0 +1,394 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.Cache = void 0;
+const guilds_1 = require("./resources/guilds");
+const users_1 = require("./resources/users");
+const channels_1 = require("./resources/channels");
+const emojis_1 = require("./resources/emojis");
+const members_1 = require("./resources/members");
+const presence_1 = require("./resources/presence");
+const roles_1 = require("./resources/roles");
+const stage_instances_1 = require("./resources/stage-instances");
+const stickers_1 = require("./resources/stickers");
+const threads_1 = require("./resources/threads");
+const voice_states_1 = require("./resources/voice-states");
+const common_1 = require("../common");
+__exportStar(require("./adapters/index"), exports);
+class Cache {
+    intents;
+    adapter;
+    disabledCache;
+    // non-guild based
+    users;
+    guilds;
+    // guild based
+    members;
+    // guild related
+    roles;
+    emojis;
+    threads;
+    channels;
+    stickers;
+    presences;
+    voiceStates;
+    stageInstances;
+    constructor(intents, adapter, disabledCache = [], client) {
+        this.intents = intents;
+        this.adapter = adapter;
+        this.disabledCache = disabledCache;
+        // non-guild based
+        if (!this.disabledCache.includes('users')) {
+            this.users = new users_1.Users(this, client);
+        }
+        if (!this.disabledCache.includes('guilds')) {
+            this.guilds = new guilds_1.Guilds(this, client);
+        }
+        // guild related
+        if (!this.disabledCache.includes('members')) {
+            this.members = new members_1.Members(this, client);
+        }
+        // guild based
+        if (!this.disabledCache.includes('roles')) {
+            this.roles = new roles_1.Roles(this, client);
+        }
+        if (!this.disabledCache.includes('channels')) {
+            this.channels = new channels_1.Channels(this, client);
+        }
+        if (!this.disabledCache.includes('emojis')) {
+            this.emojis = new emojis_1.Emojis(this, client);
+        }
+        if (!this.disabledCache.includes('stickers')) {
+            this.stickers = new stickers_1.Stickers(this, client);
+        }
+        if (!this.disabledCache.includes('presences')) {
+            this.presences = new presence_1.Presences(this, client);
+        }
+        if (!this.disabledCache.includes('voiceStates')) {
+            this.voiceStates = new voice_states_1.VoiceStates(this, client);
+        }
+        if (!this.disabledCache.includes('threads')) {
+            this.threads = new threads_1.Threads(this, client);
+        }
+        if (!this.disabledCache.includes('stageInstances')) {
+            this.stageInstances = new stage_instances_1.StageInstances(this, client);
+        }
+    }
+    /** @internal */
+    __setClient(client) {
+        this.users?.__setClient(client);
+        this.guilds?.__setClient(client);
+        this.members?.__setClient(client);
+        this.roles?.__setClient(client);
+        this.channels?.__setClient(client);
+        this.emojis?.__setClient(client);
+        this.stickers?.__setClient(client);
+        this.presences?.__setClient(client);
+        this.voiceStates?.__setClient(client);
+        this.threads?.__setClient(client);
+        this.stageInstances?.__setClient(client);
+    }
+    // internal use ./structures
+    hasIntent(intent) {
+        return (this.intents & common_1.GatewayIntentBits[intent]) === common_1.GatewayIntentBits[intent];
+    }
+    get hasGuildsIntent() {
+        return this.hasIntent('Guilds');
+    }
+    get hasRolesIntent() {
+        return this.hasGuildsIntent;
+    }
+    get hasChannelsIntent() {
+        return this.hasGuildsIntent;
+    }
+    get hasGuildMembersIntent() {
+        return this.hasIntent('GuildMembers');
+    }
+    get hasEmojisAndStickersIntent() {
+        return this.hasIntent('GuildEmojisAndStickers');
+    }
+    get hasVoiceStatesIntent() {
+        return this.hasIntent('GuildVoiceStates');
+    }
+    get hasPrenseceUpdates() {
+        return this.hasIntent('GuildPresences');
+    }
+    get hasDirectMessages() {
+        return this.hasIntent('DirectMessages');
+    }
+    async bulkGet(keys) {
+        const allData = {};
+        for (const [type, id, guildId] of keys) {
+            switch (type) {
+                case 'members':
+                    {
+                        if (!allData[type]) {
+                            allData[type] = [];
+                        }
+                        allData[type].push([id, guildId]);
+                    }
+                    break;
+                case 'roles':
+                case 'threads':
+                case 'stickers':
+                case 'channels':
+                case 'presences':
+                case 'voiceStates':
+                case 'stageInstances':
+                case 'emojis':
+                case 'users':
+                case 'guilds':
+                    {
+                        if (!allData[type]) {
+                            allData[type] = [];
+                        }
+                        allData[type].push([id]);
+                    }
+                    break;
+                default:
+                    throw new Error(`Invalid type ${type}`);
+            }
+        }
+        const obj = {};
+        for (const i in allData) {
+            const key = i;
+            const values = allData[key];
+            obj[key] = [];
+            for (const value of values) {
+                const g = await this[key]?.get(value[0], value[1]);
+                if (!g) {
+                    continue;
+                }
+                obj[key].push(g);
+            }
+        }
+        return obj;
+    }
+    async bulkPatch(keys) {
+        const allData = [];
+        const relationshipsData = {};
+        for (const [type, data, id, guildId] of keys) {
+            switch (type) {
+                case 'roles':
+                case 'threads':
+                case 'stickers':
+                case 'channels':
+                case 'presences':
+                case 'voiceStates':
+                case 'stageInstances':
+                case 'emojis':
+                    {
+                        const hashId = this[type]?.hashId(guildId);
+                        if (!hashId) {
+                            continue;
+                        }
+                        if (!(hashId in relationshipsData)) {
+                            relationshipsData[hashId] = [];
+                        }
+                        relationshipsData[hashId].push(id);
+                        data.guild_id = guildId;
+                        allData.push([this[type].hashId(id), this[type].parse(data, id, guildId)]);
+                    }
+                    break;
+                case 'members':
+                    {
+                        const hashId = this[type]?.hashId(guildId);
+                        if (!hashId) {
+                            continue;
+                        }
+                        if (!(hashId in relationshipsData)) {
+                            relationshipsData[hashId] = [];
+                        }
+                        relationshipsData[hashId].push(id);
+                        data.guild_id = guildId;
+                        allData.push([this[type].hashGuildId(id, guildId), this[type].parse(data, id, guildId)]);
+                    }
+                    break;
+                case 'users':
+                case 'guilds':
+                    {
+                        const hashId = this[type]?.namespace;
+                        if (!hashId) {
+                            continue;
+                        }
+                        if (!(hashId in relationshipsData)) {
+                            relationshipsData[hashId] = [];
+                        }
+                        relationshipsData[hashId].push(id);
+                        allData.push([this[type].hashId(id), data]);
+                    }
+                    break;
+                default:
+                    throw new Error(`Invalid type ${type}`);
+            }
+        }
+        await this.adapter.patch(false, allData);
+        await this.adapter.bulkAddToRelationShip(relationshipsData);
+    }
+    async bulkSet(keys) {
+        const allData = [];
+        const relationshipsData = {};
+        for (const [type, data, id, guildId] of keys) {
+            switch (type) {
+                case 'roles':
+                case 'threads':
+                case 'stickers':
+                case 'channels':
+                case 'presences':
+                case 'voiceStates':
+                case 'stageInstances':
+                case 'emojis':
+                    {
+                        const hashId = this[type]?.hashId(guildId);
+                        if (!hashId) {
+                            continue;
+                        }
+                        if (!(hashId in relationshipsData)) {
+                            relationshipsData[hashId] = [];
+                        }
+                        relationshipsData[hashId].push(id);
+                        data.guild_id = guildId;
+                        allData.push([this[type].hashId(id), this[type].parse(data, id, guildId)]);
+                    }
+                    break;
+                case 'members':
+                    {
+                        const hashId = this[type]?.hashId(guildId);
+                        if (!hashId) {
+                            continue;
+                        }
+                        if (!(hashId in relationshipsData)) {
+                            relationshipsData[hashId] = [];
+                        }
+                        relationshipsData[hashId].push(id);
+                        data.guild_id = guildId;
+                        allData.push([this[type].hashGuildId(id, guildId), this[type].parse(data, id, guildId)]);
+                    }
+                    break;
+                case 'users':
+                case 'guilds':
+                    {
+                        const hashId = this[type]?.namespace;
+                        if (!hashId) {
+                            continue;
+                        }
+                        if (!(hashId in relationshipsData)) {
+                            relationshipsData[hashId] = [];
+                        }
+                        relationshipsData[hashId].push(id);
+                        allData.push([this[type].hashId(id), data]);
+                    }
+                    break;
+                default:
+                    throw new Error(`Invalid type ${type}`);
+            }
+        }
+        await this.adapter.set(allData);
+        await this.adapter.bulkAddToRelationShip(relationshipsData);
+    }
+    async onPacket(event) {
+        switch (event.t) {
+            case 'READY':
+                {
+                    const data = event.d;
+                    await this.users?.set(data.user.id, data.user);
+                }
+                break;
+            case 'GUILD_CREATE':
+            case 'GUILD_UPDATE':
+                await this.guilds?.patch(event.d.id, { unavailable: false, ...event.d });
+                break;
+            case 'GUILD_DELETE':
+                if (event.d.unavailable) {
+                    await this.guilds?.patch(event.d.id, event.d);
+                }
+                else {
+                    await this.guilds?.remove(event.d.id);
+                }
+                break;
+            case 'CHANNEL_CREATE':
+            case 'CHANNEL_UPDATE':
+                if ('guild_id' in event.d) {
+                    await this.channels?.set(event.d.id, event.d.guild_id, event.d);
+                    break;
+                }
+                if (event.d.type === common_1.ChannelType.DM) {
+                    await this.channels?.set(event.d.recipients[0]?.id, '@me', event.d);
+                    break;
+                }
+                break;
+            case 'CHANNEL_DELETE':
+                await this.channels?.remove(event.d.id, 'guild_id' in event.d ? event.d.guild_id : '@me');
+                break;
+            case 'GUILD_ROLE_CREATE':
+            case 'GUILD_ROLE_UPDATE':
+                await this.roles?.set(event.d.role.id, event.d.guild_id, event.d.role);
+                break;
+            case 'GUILD_ROLE_DELETE':
+                await this.roles?.remove(event.d.role_id, event.d.guild_id);
+                break;
+            case 'GUILD_EMOJIS_UPDATE':
+                await this.emojis?.remove(await this.emojis?.keys(event.d.guild_id), event.d.guild_id);
+                await this.emojis?.set(event.d.emojis.map(x => [x.id, x]), event.d.guild_id);
+                break;
+            case 'GUILD_STICKERS_UPDATE':
+                await this.stickers?.remove(await this.stickers?.keys(event.d.guild_id), event.d.guild_id);
+                await this.stickers?.set(event.d.stickers.map(x => [x.id, x]), event.d.guild_id);
+                break;
+            case 'GUILD_MEMBER_ADD':
+            case 'GUILD_MEMBER_UPDATE':
+                if (event.d.user)
+                    await this.members?.set(event.d.user.id, event.d.guild_id, event.d);
+                break;
+            case 'GUILD_MEMBER_REMOVE':
+                await this.members?.remove(event.d.user.id, event.d.guild_id);
+                break;
+            case 'PRESENCE_UPDATE':
+                // Should update member data?
+                await this.presences?.set(event.d.user.id, event.d.guild_id, event.d);
+                break;
+            case 'THREAD_CREATE':
+            case 'THREAD_UPDATE':
+                await this.threads?.set(event.d.id, event.d.guild_id, event.d);
+                break;
+            case 'THREAD_DELETE':
+                await this.threads?.remove(event.d.id, event.d.guild_id);
+                break;
+            case 'USER_UPDATE':
+                await this.users?.set(event.d.id, event.d);
+                break;
+            case 'VOICE_STATE_UPDATE':
+                if (!event.d.guild_id) {
+                    return;
+                }
+                if (event.d.channel_id != null) {
+                    await this.voiceStates?.set(event.d.user_id, event.d.guild_id, event.d);
+                }
+                else {
+                    await this.voiceStates?.remove(event.d.user_id, event.d.guild_id);
+                }
+                break;
+            case 'STAGE_INSTANCE_CREATE':
+            case 'STAGE_INSTANCE_UPDATE':
+                await this.stageInstances?.set(event.d.id, event.d.guild_id, event.d);
+                break;
+            case 'STAGE_INSTANCE_DELETE':
+                await this.stageInstances?.remove(event.d.id, event.d.guild_id);
+                break;
+        }
+    }
+}
+exports.Cache = Cache;

package/lib/cache/resources/channels.d.ts

@@ -0,0 +1,7 @@
+import type { AllChannels } from '../../structures';
+import { GuildRelatedResource } from './default/guild-related';
+export declare class Channels extends GuildRelatedResource {
+    namespace: string;
+    get(id: string): Promise<AllChannels | undefined>;
+    values(guild: string): Promise<AllChannels[]>;
+}

package/lib/cache/resources/channels.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channels = void 0;
+const channels_1 = __importDefault(require("../../structures/channels"));
+const guild_related_1 = require("./default/guild-related");
+class Channels extends guild_related_1.GuildRelatedResource {
+    namespace = 'channel';
+    async get(id) {
+        const rawChannel = await super.get(id);
+        return rawChannel ? (0, channels_1.default)(rawChannel, this.client) : undefined;
+    }
+    async values(guild) {
+        const channels = await super.values(guild);
+        return channels.map(rawChannel => (0, channels_1.default)(rawChannel, this.client));
+    }
+}
+exports.Channels = Channels;

package/lib/cache/resources/default/base.d.ts

@@ -0,0 +1,25 @@
+import type { BaseClient } from '../../../client/base';
+import type { GatewayIntentBits } from '../../../common';
+import type { Cache } from '../../index';
+export declare class BaseResource<T = any> {
+    protected cache: Cache;
+    client: BaseClient;
+    namespace: string;
+    constructor(cache: Cache, client?: BaseClient);
+    get rest(): import("../../..").REST;
+    get adapter(): import("../../index").Adapter;
+    removeIfNI(intent: keyof typeof GatewayIntentBits, id: string): Promise<void>;
+    setIfNI(intent: keyof typeof GatewayIntentBits, id: string, data: any): Promise<any>;
+    get(id: string): Promise<T | undefined>;
+    set(id: string, data: any): Promise<void>;
+    patch<T extends Record<any, any> = Record<any, any>>(id: string, data: T): Promise<void>;
+    remove(id: string): Promise<void>;
+    keys(): Promise<string[]>;
+    values(): Promise<T[]>;
+    count(): Promise<number>;
+    contains(id: string): Promise<boolean>;
+    getToRelationship(): Promise<string[]>;
+    addToRelationship(id: string | string[]): Promise<void>;
+    removeToRelationship(id: string | string[]): Promise<void>;
+    hashId(id: string): string;
+}

package/lib/cache/resources/default/base.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResource = void 0;
+class BaseResource {
+    cache;
+    client;
+    namespace = 'base';
+    constructor(cache, client) {
+        this.cache = cache;
+        if (client) {
+            this.client = client;
+        }
+    }
+    /** @internal */
+    __setClient(client) {
+        this.client = client;
+    }
+    get rest() {
+        return this.client.rest;
+    }
+    get adapter() {
+        return this.cache.adapter;
+    }
+    async removeIfNI(intent, id) {
+        if (!this.cache.hasIntent(intent)) {
+            await this.remove(id);
+        }
+    }
+    async setIfNI(intent, id, data) {
+        if (!this.cache.hasIntent(intent)) {
+            await this.set(id, data);
+            return data;
+        }
+    }
+    async get(id) {
+        return this.adapter.get(this.hashId(id));
+    }
+    async set(id, data) {
+        await this.addToRelationship(id);
+        await this.adapter.set(this.hashId(id), data);
+    }
+    async patch(id, data) {
+        await this.addToRelationship(id);
+        await this.adapter.patch(false, this.hashId(id), data);
+    }
+    async remove(id) {
+        await this.removeToRelationship(id);
+        await this.adapter.remove(this.hashId(id));
+    }
+    async keys() {
+        return this.adapter.keys(this.namespace);
+    }
+    async values() {
+        return this.adapter.values(this.namespace);
+    }
+    async count() {
+        return this.adapter.count(this.namespace);
+    }
+    async contains(id) {
+        return this.adapter.contains(this.namespace, id);
+    }
+    async getToRelationship() {
+        return this.adapter.getToRelationship(this.namespace);
+    }
+    async addToRelationship(id) {
+        await this.adapter.addToRelationship(this.namespace, id);
+    }
+    async removeToRelationship(id) {
+        await this.adapter.removeToRelationship(this.namespace, id);
+    }
+    hashId(id) {
+        return `${this.namespace}.${id}`;
+    }
+}
+exports.BaseResource = BaseResource;

package/lib/cache/resources/default/guild-based.d.ts

@@ -0,0 +1,33 @@
+import type { BaseClient } from '../../../client/base';
+import type { GatewayIntentBits } from '../../../common';
+import type { Cache } from '../../index';
+export declare class GuildBasedResource<T = any> {
+    protected cache: Cache;
+    client: BaseClient;
+    namespace: string;
+    constructor(cache: Cache, client?: BaseClient);
+    parse(data: any, _id: string, guild_id: string): any;
+    get adapter(): import("../../index").Adapter;
+    removeIfNI(intent: keyof typeof GatewayIntentBits, id: string | string[], guildId: string): Promise<void>;
+    setIfNI(intent: keyof typeof GatewayIntentBits, id: string, guildId: string, data: any): Promise<any>;
+    get(id: string, guild: string): Promise<(T & {
+        guild_id: string;
+    }) | undefined>;
+    set(__keys: string, guild: string, data: any): Promise<void>;
+    set(__keys: [string, any][], guild: string): Promise<void>;
+    patch(__keys: string, guild: string, data: any): Promise<void>;
+    patch(__keys: [string, any][], guild: string): Promise<void>;
+    remove(id: string | string[], guild: string): Promise<void>;
+    keys(guild: string): Promise<string[]>;
+    values(guild: string): Promise<(T & {
+        guild_id: string;
+    })[]>;
+    count(guild: string): Promise<number>;
+    contains(id: string, guild: string): Promise<boolean>;
+    getToRelationship(guild: string): Promise<string[]>;
+    addToRelationship(id: string | string[], guild: string): Promise<void>;
+    removeToRelationship(id: string | string[], guild: string): Promise<void>;
+    removeRelationship(id: string | string[]): Promise<void>;
+    hashId(id: string): string;
+    hashGuildId(guild: string, id: string): string;
+}

package/lib/cache/resources/default/guild-based.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildBasedResource = void 0;
+class GuildBasedResource {
+    cache;
+    client;
+    namespace = 'base';
+    constructor(cache, client) {
+        this.cache = cache;
+        if (client) {
+            this.client = client;
+        }
+    }
+    /** @internal */
+    __setClient(client) {
+        this.client = client;
+    }
+    parse(data, _id, guild_id) {
+        data.guild_id = guild_id;
+        return data;
+    }
+    get adapter() {
+        return this.cache.adapter;
+    }
+    async removeIfNI(intent, id, guildId) {
+        if (!this.cache.hasIntent(intent)) {
+            await this.remove(id, guildId);
+        }
+    }
+    async setIfNI(intent, id, guildId, data) {
+        if (!this.cache.hasIntent(intent)) {
+            await this.set(id, guildId, data);
+            return data;
+        }
+    }
+    async get(id, guild) {
+        return this.adapter.get(this.hashGuildId(id, guild));
+    }
+    async set(__keys, guild, data) {
+        const keys = Array.isArray(__keys) ? __keys : [[__keys, data]];
+        await this.addToRelationship(keys.map(x => x[0]), guild);
+        await this.adapter.set(keys.map(([key, value]) => {
+            return [this.hashGuildId(key, guild), this.parse(value, key, guild)];
+        }));
+    }
+    async patch(__keys, guild, data) {
+        const keys = Array.isArray(__keys) ? __keys : [[__keys, data]];
+        const oldDatas = await this.adapter.get(keys.map(([key]) => this.hashGuildId(key, guild)));
+        await this.addToRelationship(keys.map(x => x[0]), guild);
+        await this.adapter.set(keys.map(([key, value]) => {
+            const oldData = oldDatas.find(x => x.id === key) ?? {};
+            return [this.hashGuildId(key, guild), this.parse({ ...oldData, ...value }, key, guild)];
+        }));
+    }
+    async remove(id, guild) {
+        const ids = Array.isArray(id) ? id : [id];
+        await this.removeToRelationship(ids, guild);
+        await this.adapter.remove(ids.map(x => this.hashGuildId(x, guild)));
+    }
+    async keys(guild) {
+        return this.adapter.scan(this.hashGuildId(guild, '*'), true);
+    }
+    async values(guild) {
+        return this.adapter.scan(this.hashGuildId(guild, '*'));
+    }
+    async count(guild) {
+        return (await this.adapter.scan(this.hashGuildId(guild, '*'), true)).length;
+    }
+    async contains(id, guild) {
+        return this.adapter.contains(this.hashId(guild), id);
+    }
+    async getToRelationship(guild) {
+        return this.adapter.getToRelationship(this.hashId(guild));
+    }
+    async addToRelationship(id, guild) {
+        await this.adapter.addToRelationship(this.hashId(guild), id);
+    }
+    async removeToRelationship(id, guild) {
+        await this.adapter.removeToRelationship(this.hashId(guild), id);
+    }
+    async removeRelationship(id) {
+        await this.adapter.removeRelationship((Array.isArray(id) ? id : [id]).map(x => this.hashId(x)));
+    }
+    hashId(id) {
+        return `${this.namespace}.${id}`;
+    }
+    hashGuildId(guild, id) {
+        return `${this.namespace}.${guild}.${id}`;
+    }
+}
+exports.GuildBasedResource = GuildBasedResource;

package/lib/cache/resources/default/guild-related.d.ts

@@ -0,0 +1,32 @@
+import type { BaseClient } from '../../../client/base';
+import type { GatewayIntentBits } from '../../../common';
+import type { Cache } from '../../index';
+export declare class GuildRelatedResource<T = any> {
+    protected cache: Cache;
+    client: BaseClient;
+    namespace: string;
+    constructor(cache: Cache, client?: BaseClient);
+    parse(data: any, _id: string, guild_id: string): any;
+    get adapter(): import("../../index").Adapter;
+    removeIfNI(intent: keyof typeof GatewayIntentBits, id: string | string[], guildId: string): Promise<void>;
+    setIfNI(intent: keyof typeof GatewayIntentBits, id: string, guildId: string, data: any): Promise<any>;
+    get(id: string): Promise<(T & {
+        guild_id: string;
+    }) | undefined>;
+    set(__keys: string, guild: string, data: any): Promise<void>;
+    set(__keys: [string, any][], guild: string): Promise<void>;
+    patch(__keys: string, guild?: string, data?: any): Promise<void>;
+    patch(__keys: [string, any][], guild?: string): Promise<void>;
+    remove(id: string | string[], guild: string): Promise<void>;
+    keys(guild: string): Promise<string[]>;
+    values(guild: string): Promise<(T & {
+        guild_id: string;
+    })[]>;
+    count(to: string): Promise<number>;
+    contains(id: string, guild: string): Promise<boolean>;
+    getToRelationship(guild: string): Promise<string[]>;
+    addToRelationship(id: string | string[], guild: string): Promise<void>;
+    removeToRelationship(id: string | string[], guild: string): Promise<void>;
+    removeRelationship(id: string | string[]): Promise<void>;
+    hashId(id: string): string;
+}