seyfert 4.4.1 → 5.0.0

package/lib/client/plugins/shared.d.ts

@@ -0,0 +1,23 @@
+import type { Awaitable } from '../../common/types/util';
+import type { BaseClient } from '../base';
+import { type PluginEventContributionScope, type PluginRuntimeRecord, type PluginRuntimeRegistry } from './registry';
+import type { PluginSharedRegistry, RegisteredPluginShared, SharedKey } from './types';
+type SharedFactory = (client: BaseClient) => unknown;
+type SharedDispose = (value: unknown) => Awaitable<void>;
+export declare function createSharedKey<const Name extends keyof RegisteredPluginShared & string>(name: Name): SharedKey<RegisteredPluginShared[Name], Name>;
+export declare function createSharedKey<T>(): <const Name extends string>(name: Name) => SharedKey<T, Name>;
+export declare function createSharedKey<const Name extends string>(name: Name): SharedKey<unknown, Name>;
+export declare function sharedName(name: string | SharedKey<unknown, string>): string;
+export declare function addPluginShared(registry: PluginRuntimeRegistry, record: PluginRuntimeRecord, name: string, factory: SharedFactory, scope: PluginEventContributionScope, opts?: {
+    dispose?: SharedDispose;
+    override?: boolean;
+}): void;
+export declare function removePluginShared(registry: PluginRuntimeRegistry, record: PluginRuntimeRecord, names: readonly string[], scope: PluginEventContributionScope): void;
+export declare function createSharedRegistry(client: BaseClient, registry: PluginRuntimeRegistry): PluginSharedRegistry;
+export declare function disposePluginSharedValues(shared: PluginSharedRegistry, registry: PluginRuntimeRegistry, record: PluginRuntimeRecord): Promise<unknown[]>;
+export declare function cleanupPluginSharedContributions(registry: PluginRuntimeRegistry, record: PluginRuntimeRecord, shouldRemove: (contribution: {
+    scope: PluginEventContributionScope;
+}) => boolean): void;
+export declare function cleanupPluginDynamicSharedContributions(registry: PluginRuntimeRegistry, record: PluginRuntimeRecord): Promise<unknown[]>;
+export declare function clearSharedRegistryInstances(shared: PluginSharedRegistry): void;
+export {};

package/lib/client/plugins/shared.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSharedKey = createSharedKey;
+exports.sharedName = sharedName;
+exports.addPluginShared = addPluginShared;
+exports.removePluginShared = removePluginShared;
+exports.createSharedRegistry = createSharedRegistry;
+exports.disposePluginSharedValues = disposePluginSharedValues;
+exports.cleanupPluginSharedContributions = cleanupPluginSharedContributions;
+exports.cleanupPluginDynamicSharedContributions = cleanupPluginDynamicSharedContributions;
+exports.clearSharedRegistryInstances = clearSharedRegistryInstances;
+const errors_1 = require("./errors");
+const order_1 = require("./order");
+const registry_1 = require("./registry");
+const sharedStates = new WeakMap();
+function createSharedKey(name) {
+    if (name === undefined)
+        return keyName => Object.freeze({ name: keyName });
+    return Object.freeze({ name });
+}
+function sharedName(name) {
+    return typeof name === 'string' ? name : name.name;
+}
+function addPluginShared(registry, record, name, factory, scope, opts) {
+    const owner = registry.sharedOwners.get(name);
+    trackDynamicSharedMutation(registry, record, name, scope);
+    if (owner) {
+        if (!opts?.override) {
+            throw (0, errors_1.createPluginConflictError)(record.plugin.name, `shared.${name}`, record.index, `Shared value "${name}" is already claimed by plugin "${owner.plugin.name}".`, record.plugin.instanceId);
+        }
+        (0, registry_1.assertCanMutatePluginContribution)(registry, record, 'override', 'shared', name, owner, `shared.${name}`);
+        queueSharedDisposal(registry, name);
+        recordSharedMutationDiagnostic(registry, record, 'override', name, owner);
+    }
+    registry.sharedOwners.set(name, record);
+    registry.shared.set(name, { record, factory, dispose: opts?.dispose, scope });
+}
+function removePluginShared(registry, record, names, scope) {
+    for (const name of names) {
+        const owner = registry.sharedOwners.get(name);
+        if (!owner)
+            continue;
+        trackDynamicSharedMutation(registry, record, name, scope);
+        (0, registry_1.assertCanMutatePluginContribution)(registry, record, 'remove', 'shared', name, owner, `shared.${name}`);
+        queueSharedDisposal(registry, name);
+        registry.shared.delete(name);
+        if (registry.sharedOwners.get(name) === owner)
+            registry.sharedOwners.delete(name);
+        recordSharedMutationDiagnostic(registry, record, 'remove', name, owner);
+    }
+}
+function createSharedRegistry(client, registry) {
+    const instances = new Map();
+    const resolve = (name) => {
+        if (instances.has(name))
+            return instances.get(name);
+        const shared = registry.shared.get(name);
+        if (!shared)
+            return undefined;
+        let value;
+        try {
+            value = shared.factory(client);
+        }
+        catch (error) {
+            throw (0, errors_1.wrapPluginError)(shared.record.plugin.name, `shared.${name}`, shared.record.index, error, undefined, shared.record.plugin.instanceId);
+        }
+        instances.set(name, value);
+        return value;
+    };
+    const shared = Object.freeze({
+        get(name) {
+            return resolve(sharedName(name));
+        },
+        unwrap(name) {
+            const key = sharedName(name);
+            if (!registry.shared.has(key)) {
+                throw (0, errors_1.createPluginConflictError)('<shared>', `shared.${key}`, -1, `Shared value "${key}" is not registered.`);
+            }
+            return resolve(key);
+        },
+        has(name) {
+            return registry.shared.has(sharedName(name));
+        },
+    });
+    sharedStates.set(shared, { instances });
+    return shared;
+}
+async function disposePluginSharedValues(shared, registry, record) {
+    const state = sharedStates.get(shared);
+    if (!state)
+        return [];
+    const errors = [];
+    for (const [name, contribution] of [...registry.shared.entries()].reverse()) {
+        if (contribution.record !== record || !state.instances.has(name))
+            continue;
+        const value = state.instances.get(name);
+        try {
+            await contribution.dispose?.(value);
+        }
+        catch (error) {
+            errors.push((0, errors_1.wrapPluginError)(contribution.record.plugin.name, `shared.${name}`, contribution.record.index, error, 'PLUGIN_TEARDOWN_FAILED', contribution.record.plugin.instanceId));
+        }
+        finally {
+            state.instances.delete(name);
+        }
+    }
+    errors.push(...(await drainQueuedSharedDisposals(registry)));
+    return errors;
+}
+function cleanupPluginSharedContributions(registry, record, shouldRemove) {
+    for (const [name, contribution] of registry.shared) {
+        if (contribution.record !== record || !shouldRemove(contribution))
+            continue;
+        registry.shared.delete(name);
+        if (registry.sharedOwners.get(name) === record)
+            registry.sharedOwners.delete(name);
+    }
+}
+async function cleanupPluginDynamicSharedContributions(registry, record) {
+    const errors = [];
+    for (let index = registry.sharedMutations.length - 1; index >= 0; index--) {
+        const mutation = registry.sharedMutations[index];
+        if (mutation.record !== record || mutation.scope === 'register')
+            continue;
+        const error = await disposeSharedInstance(registry, mutation.name);
+        if (error)
+            errors.push(error);
+        if (mutation.previous) {
+            registry.shared.set(mutation.name, mutation.previous);
+            if (mutation.previousOwner)
+                registry.sharedOwners.set(mutation.name, mutation.previousOwner);
+            else
+                registry.sharedOwners.delete(mutation.name);
+        }
+        else {
+            registry.shared.delete(mutation.name);
+            registry.sharedOwners.delete(mutation.name);
+        }
+        registry.sharedMutations.splice(index, 1);
+    }
+    cleanupPluginSharedContributions(registry, record, contribution => contribution.scope !== 'register');
+    errors.push(...(await drainQueuedSharedDisposals(registry)));
+    return errors;
+}
+function clearSharedRegistryInstances(shared) {
+    sharedStates.get(shared)?.instances.clear();
+}
+function queueSharedDisposal(registry, name) {
+    registry.sharedDisposals.push(disposeSharedInstance(registry, name));
+}
+async function drainQueuedSharedDisposals(registry) {
+    const pending = registry.sharedDisposals.splice(0);
+    const errors = [];
+    for (const error of await Promise.all(pending)) {
+        if (error !== undefined)
+            errors.push(error);
+    }
+    return errors;
+}
+async function disposeSharedInstance(registry, name) {
+    const shared = registry.client?.shared;
+    if (!shared)
+        return;
+    const state = sharedStates.get(shared);
+    if (!state?.instances.has(name))
+        return;
+    const value = state.instances.get(name);
+    const contribution = registry.shared.get(name);
+    try {
+        await contribution?.dispose?.(value);
+    }
+    catch (error) {
+        return (0, errors_1.wrapPluginError)(contribution?.record.plugin.name ?? '<unknown>', `shared.${name}`, contribution?.record.index ?? -1, error, 'PLUGIN_TEARDOWN_FAILED', contribution?.record.plugin.instanceId);
+    }
+    finally {
+        state.instances.delete(name);
+    }
+    return undefined;
+}
+function recordSharedMutationDiagnostic(registry, record, action, name, owner) {
+    (0, registry_1.recordContributionMutationDiagnostic)(registry, { record, sequence: (0, order_1.nextPluginContributionSequence)(registry) }, action, 'shared', name, owner, `shared.${name}`);
+}
+function trackDynamicSharedMutation(registry, record, name, scope) {
+    if (scope === 'register')
+        return;
+    registry.sharedMutations.push({
+        record,
+        name,
+        scope,
+        previous: registry.shared.get(name),
+        previousOwner: registry.sharedOwners.get(name),
+    });
+}

package/lib/client/plugins/types.d.ts

@@ -0,0 +1,398 @@
+import type { RestObserver, RestObserverFailPayload, RestObserverRatelimitPayload, RestObserverRequestPayload, RestObserverSuccessPayload } from '../../api/shared';
+import type { BaseResource, Cache } from '../../cache';
+import type { AnyMiddlewareContext, Command, CommandContext, ContextMenuCommand, EntryPointCommand, EntryPointContext, MenuCommandContext, MiddlewareContext, SubCommand, UsingClient } from '../../commands';
+import type { CommandAutocompleteOption } from '../../commands/applications/chat';
+import type { HandleableCommand, HandleableCommandInstance } from '../../commands/handler';
+import type { Awaitable } from '../../common/types/util';
+import type { ComponentCommand, ModalCommand } from '../../components';
+import type { ClientEvent, ClientNameEvents, CustomEventsKeys } from '../../events';
+import type { GatewayEvents, ResolveEventParams } from '../../events/handler';
+import type { AutocompleteInteraction } from '../../structures';
+import type { GatewayDispatchPayload, GatewayIntentBits, GatewaySendPayload, LocaleString } from '../../types';
+import type { BaseClient, BaseClientOptions } from '../base';
+import type { MessageStructure, OptionResolverStructure } from '../transformers';
+export interface SeyfertRegistry {
+}
+export interface RegisteredPluginShared {
+}
+export interface SharedKey<T, Name extends string = string> {
+    readonly name: Name;
+    readonly __shared?: T;
+}
+export type SharedValue<T> = T extends SharedKey<infer Value, string> ? Value : never;
+export interface PluginSharedRegistry {
+    get<const Name extends keyof RegisteredPluginShared & string>(name: Name): RegisteredPluginShared[Name] | undefined;
+    get<T, const Name extends string>(key: SharedKey<T, Name>): T | undefined;
+    unwrap<const Name extends keyof RegisteredPluginShared & string>(name: Name): RegisteredPluginShared[Name];
+    unwrap<T, const Name extends string>(key: SharedKey<T, Name>): T;
+    has<const Name extends string>(name: Name | SharedKey<unknown, Name>): boolean;
+}
+export interface PluginSharedOptions<T> {
+    dispose?: (value: T) => Awaitable<void>;
+    override?: boolean;
+}
+export interface PluginLangOptions {
+    readonly prefix: string;
+}
+export interface PluginCommandContributionOptions extends PluginContributionOptions {
+    guilds?: readonly string[];
+}
+export interface PluginMiddlewareDenialMetadata {
+    middleware: string;
+    scope: 'global' | 'command';
+}
+export declare enum PluginOrder {
+    Before = "before",
+    After = "after"
+}
+export type PluginOrderOpt = PluginOrder.Before | PluginOrder.After | number;
+export type PluginDiagnosticSeverity = 'info' | 'warn' | 'error';
+export type PluginDiagnosticCode = 'missing-optional-requirement' | 'unknown-intent-bits' | 'gateway-send-payload-veto' | 'gateway-dispatch-veto' | 'contribution-override' | 'contribution-removed' | 'command-guild-scope' | 'static-keys-multi-instance' | (string & {});
+export type PluginLifecycleStatus = 'registered' | 'setting-up' | 'ready' | 'closing' | 'closed' | 'failed';
+export type PluginRequirement = `plugin:${string}`;
+type SemverVersion = `${number}.${number}.${number}${string}`;
+export type SemverRange = SemverVersion | `>=${SemverVersion}` | `^${SemverVersion}` | `~${SemverVersion}`;
+export type PluginRequirementInput = PluginRequirement | {
+    req: PluginRequirement;
+    range?: SemverRange;
+    optional?: boolean;
+    capability?: never;
+} | {
+    capability: SharedKey<unknown, string>;
+    optional?: boolean;
+    req?: never;
+    range?: never;
+};
+export type PluginIntentResolvable = keyof typeof GatewayIntentBits | GatewayIntentBits | number;
+export type PluginLifecyclePhase = 'resolve' | 'requires' | 'options' | 'register' | 'client' | 'ctx' | 'shared' | 'commands.add' | 'components.add' | 'setup' | 'teardown' | `event:${string}`;
+export interface PluginDiagnosticMessage {
+    plugin: string;
+    instanceId?: string;
+    index: number;
+    phase: PluginLifecyclePhase | string;
+    severity: PluginDiagnosticSeverity;
+    code?: PluginDiagnosticCode;
+    message: string;
+    data?: Record<string, unknown>;
+}
+export interface PluginRequirementDiagnostic {
+    kind: 'plugin' | 'capability';
+    req: PluginRequirement | string;
+    range?: SemverRange;
+    resolvedVersion?: string;
+    optional: boolean;
+    satisfied: boolean;
+}
+export interface PluginLoadedMetadata<TKind extends 'commands' | 'components', TItem = unknown> {
+    kind: TKind;
+    total: number;
+    items: readonly TItem[];
+    plugin: {
+        total: number;
+        sources: Readonly<Record<string, number>>;
+    };
+}
+export interface PluginUploadCommandsMetadata {
+    applicationId: string;
+    cachePath?: string;
+    commands: number;
+    guildId?: string;
+    reason: 'cache-hit' | 'cache-miss' | 'forced';
+    scope: 'global' | 'guild';
+    status: 'skipped' | 'uploaded';
+}
+export interface PluginAutocompletePayload {
+    client: BaseClient;
+    command?: CommandAutocompleteOption;
+    interaction: AutocompleteInteraction;
+    optionsResolver: OptionResolverStructure;
+}
+export type PluginAutocompleteNext = () => Awaitable<void>;
+export type PluginAutocompleteWrapper = (payload: PluginAutocompletePayload, next: PluginAutocompleteNext) => Awaitable<void>;
+export interface PluginGatewaySendPayload {
+    client: BaseClient;
+    payload: GatewaySendPayload;
+    shardId: number;
+}
+export type PluginGatewaySendPayloadWrapper = (payload: PluginGatewaySendPayload) => Awaitable<GatewaySendPayload | null | undefined | void>;
+export interface PluginGatewayDispatchMeta {
+    readonly client: BaseClient;
+    readonly shardId: number;
+}
+export type PluginGatewayDispatchNext = (packet?: GatewayDispatchPayload) => Awaitable<GatewayDispatchPayload | null>;
+export type PluginGatewayDispatchInterceptor = (packet: GatewayDispatchPayload, next: PluginGatewayDispatchNext, meta: PluginGatewayDispatchMeta) => Awaitable<GatewayDispatchPayload | null | undefined | void>;
+export type PluginRestRequestPayload = RestObserverRequestPayload<BaseClient>;
+export type PluginRestSuccessPayload = RestObserverSuccessPayload<BaseClient>;
+export type PluginRestFailPayload = RestObserverFailPayload<BaseClient>;
+export type PluginRestRatelimitPayload = RestObserverRatelimitPayload<BaseClient>;
+export type PluginRestObserver = RestObserver<BaseClient>;
+export type PluginCacheResourceConstructor<T extends BaseResource = BaseResource> = new (cache: Cache, client: UsingClient) => T;
+export interface PluginCacheResourceOptions {
+    onPacket?(event: GatewayDispatchPayload, cache: Cache): Awaitable<void>;
+    intents?: readonly PluginIntentResolvable[];
+}
+export interface SeyfertPluginHooks {
+    'plugins:ready': [client: BaseClient];
+    'plugins:setupComplete': [client: BaseClient];
+    'commands:beforeLoad': [client: BaseClient, dir: string | undefined];
+    'commands:afterLoad': [metadata: PluginLoadedMetadata<'commands'>];
+    'components:beforeLoad': [client: BaseClient, dir: string | undefined];
+    'components:afterLoad': [metadata: PluginLoadedMetadata<'components'>];
+    'events:beforeLoad': [client: BaseClient, dir: string | undefined];
+    'events:afterLoad': [client: BaseClient, dir: string | undefined];
+    'client:close': [client: BaseClient];
+}
+export type PluginHookName = keyof SeyfertPluginHooks & string;
+export type PluginHookPayload<K extends PluginHookName> = SeyfertPluginHooks[K] extends readonly unknown[] ? SeyfertPluginHooks[K] : never;
+type PluginHookPayloadClientView<T, E extends object> = T extends BaseClient ? T & E : T;
+type PluginHookPayloadTupleView<T extends readonly unknown[], E extends object> = T extends readonly [
+    infer Head,
+    ...infer Tail
+] ? [PluginHookPayloadClientView<Head, E>, ...PluginHookPayloadTupleView<Tail, E>] : [];
+export type PluginHookPayloadFor<K extends PluginHookName, E extends object = {}> = PluginHookPayloadTupleView<PluginHookPayload<K>, E>;
+export type PluginHookHandler<K extends PluginHookName = PluginHookName, E extends object = {}> = (...args: PluginHookPayloadFor<K, E>) => Awaitable<unknown>;
+export type SeyfertPluginOptions<TOptions extends BaseClientOptions = BaseClientOptions> = Partial<Omit<TOptions, 'plugins'>>;
+export type SeyfertCommandDefaults<TOptions extends BaseClientOptions = BaseClientOptions> = NonNullable<NonNullable<TOptions['commands']>['defaults']>;
+export type SeyfertComponentDefaults<TOptions extends BaseClientOptions = BaseClientOptions> = NonNullable<NonNullable<TOptions['components']>['defaults']>;
+export type SeyfertModalDefaults<TOptions extends BaseClientOptions = BaseClientOptions> = NonNullable<NonNullable<TOptions['modals']>['defaults']>;
+export type PluginClientMap<T extends object, I extends readonly AnySeyfertPlugin[] = readonly []> = {
+    readonly [K in keyof T]: (client: BaseClient & ExtendOf<I>) => T[K];
+};
+export type PluginContextInteraction = Parameters<NonNullable<BaseClientOptions['context']>>[0] | MessageStructure;
+export type PluginContextMap<T extends object, I extends readonly AnySeyfertPlugin[] = readonly [], E extends object = {}> = {
+    readonly [K in keyof T]: (interaction: PluginContextInteraction, client: BaseClient & ExtendOf<I> & E) => T[K];
+};
+export type PluginMiddlewareMap = Record<string, AnyMiddlewareContext>;
+export type AnySeyfertPlugin = SeyfertPlugin<any, any, readonly AnySeyfertPlugin[], any>;
+export type PluginExtensionOf<T> = T extends SeyfertPlugin<infer E, any, any, any> ? E : {};
+export type PluginContextOf<T> = T extends SeyfertPlugin<any, infer C, any, any> ? C : {};
+export type PluginMiddlewaresOf<T> = T extends SeyfertPlugin<any, any, any, infer M> ? (IsOpenPluginMiddlewareMap<M> extends true ? {} : M) : {};
+type PluginImportsOf<T> = T extends SeyfertPlugin<any, any, infer I, any> ? I[number] : never;
+type PluginClosureDepth = [never, 0, 1, 2, 3, 4, 5];
+type PluginClosureOf<T, Depth extends number = 5> = [Depth] extends [0] ? T : T | PluginClosureOf<PluginImportsOf<T>, PluginClosureDepth[Depth]>;
+type PluginTupleClosure<TPlugins extends readonly AnySeyfertPlugin[]> = PluginClosureOf<TPlugins[number]>;
+export type ExtendOf<TPlugins extends readonly AnySeyfertPlugin[]> = UnionToIntersection<PluginExtensionOf<PluginTupleClosure<TPlugins>>>;
+export type ContextOf<TPlugins extends readonly AnySeyfertPlugin[]> = UnionToIntersection<PluginContextOf<PluginTupleClosure<TPlugins>>>;
+export type MiddlewaresOf<TPlugins extends readonly AnySeyfertPlugin[]> = UnionToIntersection<PluginMiddlewaresOf<PluginTupleClosure<TPlugins>>>;
+export type RegisteredPlugins = SeyfertRegistry extends {
+    plugins: infer T extends readonly AnySeyfertPlugin[];
+} ? T : readonly [];
+export type RegisteredPluginExtension = Materialize<ExtendOf<RegisteredPlugins>>;
+export type RegisteredPluginContext = Materialize<ContextOf<RegisteredPlugins>>;
+export type RegisteredPluginMiddlewares = Materialize<MiddlewaresOf<RegisteredPlugins>>;
+export type PluginUsingClient<TPlugins extends readonly AnySeyfertPlugin[] = RegisteredPlugins> = BaseClient & Materialize<ExtendOf<TPlugins>>;
+export type PluginContextMapOf<TPlugins extends readonly AnySeyfertPlugin[] = RegisteredPlugins> = Materialize<ContextOf<TPlugins>>;
+export type PluginMiddlewaresMapOf<TPlugins extends readonly AnySeyfertPlugin[] = RegisteredPlugins> = Materialize<MiddlewaresOf<TPlugins>>;
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer R) => void ? R : never;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type IsOpenPluginMiddlewareMap<T> = IsAny<T> extends true ? true : string extends keyof T ? true : false;
+type Materialize<T> = {
+    [K in keyof T]: T[K];
+};
+export type HandleableComponent = new () => ComponentCommand;
+export type HandleableModal = new () => ModalCommand;
+export type PluginCommandInstance = HandleableCommandInstance;
+export type PluginComponentInstance = ComponentCommand;
+export type PluginModalInstance = ModalCommand;
+export type PluginCommandLoadable = HandleableCommand | PluginCommandInstance;
+export type PluginComponentLoadable = HandleableComponent | PluginComponentInstance;
+export type PluginModalLoadable = HandleableModal | PluginModalInstance;
+export type PluginHandlerKind = 'command' | 'component' | 'modal' | 'event';
+export type PluginHandlerConstructor = HandleableCommand | HandleableComponent | HandleableModal;
+export type PluginHandlerInstance = PluginCommandInstance | PluginComponentInstance | PluginModalInstance;
+/** Raw event module export: a `createEvent` object, or a class to be normalized into one (e.g. DI containers). */
+export type PluginEventLoadable = ClientEvent | object;
+export interface PluginHandlerValueByKind {
+    command: PluginCommandInstance;
+    component: PluginComponentInstance;
+    modal: PluginModalInstance;
+    event: PluginEventLoadable;
+}
+export interface PluginHandlerMetadata<K extends PluginHandlerKind = PluginHandlerKind> {
+    kind: K;
+}
+export type PluginHandlerCreator = <T extends PluginHandlerConstructor>(constructor: T, next: () => InstanceType<T>, metadata: PluginHandlerMetadata) => InstanceType<T>;
+export type PluginHandlerTransformer = <K extends PluginHandlerKind = PluginHandlerKind>(instance: PluginHandlerValueByKind[K], metadata: PluginHandlerMetadata<K>) => PluginHandlerValueByKind[K] | void;
+export interface PluginHandlerOptions {
+    kinds?: readonly PluginHandlerKind[];
+    order?: PluginOrderOpt;
+}
+export type PluginDisposer = () => void;
+export type PluginEventErrorHandler = (error: unknown, name: string) => unknown;
+export interface PluginContributionOptions {
+    override?: boolean;
+}
+export interface PluginMiddlewareOptions extends PluginContributionOptions {
+    global?: boolean;
+    order?: PluginOrderOpt;
+}
+export type PluginCommandObserverContext = CommandContext | MenuCommandContext<any, never> | EntryPointContext;
+export type PluginCommandObserverCommand = Command | SubCommand | ContextMenuCommand | EntryPointCommand;
+export interface PluginCommandObserver {
+    onBeforeOptions?(context: CommandContext): Awaitable<unknown>;
+    onBeforeMiddlewares?(context: PluginCommandObserverContext): Awaitable<unknown>;
+    onMiddlewaresError?(context: PluginCommandObserverContext, error: string, metadata: PluginMiddlewareDenialMetadata): Awaitable<unknown>;
+    onRunError?(context: PluginCommandObserverContext, error: unknown): Awaitable<unknown>;
+    onAfterRun?(context: PluginCommandObserverContext, error: unknown | undefined): Awaitable<unknown>;
+    onInternalError?(client: UsingClient, command: PluginCommandObserverCommand, error?: unknown): Awaitable<unknown>;
+}
+export interface SeyfertPluginApi<M extends PluginMiddlewareMap = PluginMiddlewareMap, E extends object = {}> {
+    has(req: PluginRequirement): boolean;
+    events: {
+        on<E extends ClientNameEvents | CustomEventsKeys | GatewayEvents>(name: E, handler: (...args: ResolveEventParams<E>) => unknown, opts?: {
+            once?: boolean;
+            order?: PluginOrderOpt;
+        }): PluginDisposer;
+        once<E extends ClientNameEvents | CustomEventsKeys | GatewayEvents>(name: E, handler: (...args: ResolveEventParams<E>) => unknown): PluginDisposer;
+        onAny(handler: (name: string, ...args: unknown[]) => unknown, opts?: {
+            order?: PluginOrderOpt;
+        }): PluginDisposer;
+        onError(handler: PluginEventErrorHandler, opts?: {
+            order?: PluginOrderOpt;
+        }): PluginDisposer;
+    };
+    commands: {
+        add(...commands: PluginCommandLoadable[]): void;
+        add(...args: [...commands: PluginCommandLoadable[], opts: PluginCommandContributionOptions]): void;
+        remove(...names: string[]): void;
+        observe(observer: PluginCommandObserver, opts?: {
+            order?: PluginOrderOpt;
+        }): PluginDisposer;
+        defaults(hooks: Partial<SeyfertCommandDefaults>, opts?: {
+            suppressDefault?: boolean | readonly (keyof SeyfertCommandDefaults)[];
+            order?: PluginOrderOpt;
+        }): void;
+    };
+    rest: {
+        observe(observer: PluginRestObserver, opts?: {
+            order?: PluginOrderOpt;
+        }): PluginDisposer;
+    };
+    hooks: {
+        on<K extends PluginHookName>(name: K, handler: PluginHookHandler<K, E>, opts?: {
+            order?: PluginOrderOpt;
+        }): PluginDisposer;
+    };
+    handlers: {
+        construct(creator: PluginHandlerCreator, opts?: PluginHandlerOptions): void;
+        transform(transformer: PluginHandlerTransformer, opts?: PluginHandlerOptions): void;
+    };
+    components: {
+        add(...components: PluginComponentLoadable[]): void;
+        add(...args: [...components: PluginComponentLoadable[], opts: PluginContributionOptions]): void;
+        remove(...customIds: string[]): void;
+        defaults(hooks: Partial<SeyfertComponentDefaults>, opts?: {
+            suppressDefault?: boolean | readonly (keyof SeyfertComponentDefaults)[];
+            order?: PluginOrderOpt;
+        }): void;
+    };
+    modals: {
+        add(...modals: PluginModalLoadable[]): void;
+        add(...args: [...modals: PluginModalLoadable[], opts: PluginContributionOptions]): void;
+        remove(...customIds: string[]): void;
+        defaults(hooks: Partial<SeyfertModalDefaults>, opts?: {
+            suppressDefault?: boolean | readonly (keyof SeyfertModalDefaults)[];
+            order?: PluginOrderOpt;
+        }): void;
+    };
+    middlewares: {
+        add<const Name extends keyof M & string>(name: Name, middleware: M[Name], opts?: PluginMiddlewareOptions): void;
+        add<const Name extends string>(name: Name extends keyof M & string ? never : Name, middleware: MiddlewareContext, opts?: PluginMiddlewareOptions): void;
+        remove(...names: string[]): void;
+    };
+    autocomplete: {
+        wrap(wrapper: PluginAutocompleteWrapper, opts?: {
+            order?: PluginOrderOpt;
+        }): void;
+    };
+    gateway: {
+        addIntents(...intents: PluginIntentResolvable[]): void;
+        wrapSendPayload(wrapper: PluginGatewaySendPayloadWrapper, opts?: {
+            order?: PluginOrderOpt;
+        }): void;
+        onDispatch(interceptor: PluginGatewayDispatchInterceptor, opts?: {
+            order?: PluginOrderOpt;
+        }): PluginDisposer;
+    };
+    cache: {
+        resource(name: string, resource: PluginCacheResourceConstructor, opts?: PluginCacheResourceOptions): void;
+    };
+    shared: {
+        set<T, const Name extends string>(key: SharedKey<T, Name>, factory: (client: BaseClient & E) => T, opts?: PluginSharedOptions<T>): void;
+        set<const Name extends keyof RegisteredPluginShared & string>(name: Name, factory: (client: BaseClient & E) => RegisteredPluginShared[Name], opts?: PluginSharedOptions<RegisteredPluginShared[Name]>): void;
+        remove(...names: (string | SharedKey<unknown, string>)[]): void;
+        has<const Name extends string>(name: Name | SharedKey<unknown, Name>): boolean;
+    };
+    langs: {
+        contribute(locale: LocaleString | string, values: Record<string, unknown>, opts: PluginLangOptions): void;
+    };
+    reload(): Promise<void>;
+    diagnostics: {
+        warn(message: string, options?: {
+            code?: PluginDiagnosticCode;
+            phase?: PluginLifecyclePhase | string;
+            data?: Record<string, unknown>;
+        }): void;
+    };
+    options: {
+        set(fragment: SeyfertPluginOptions): void;
+    };
+}
+export type SeyfertPluginTeardownApi = Pick<SeyfertPluginApi, 'has' | 'diagnostics'> & {
+    shared: Pick<SeyfertPluginApi['shared'], 'has'>;
+};
+export type ResolvedPluginList = readonly AnySeyfertPlugin[] & {
+    readonly resolved: readonly AnySeyfertPlugin[];
+    readonly diagnostics: readonly PluginDiagnostics[];
+};
+export type SeyfertPluginClient = BaseClient & {
+    plugins: ResolvedPluginList;
+};
+export interface SeyfertPlugin<E extends object = {}, C extends object = {}, I extends readonly AnySeyfertPlugin[] = readonly [], M extends PluginMiddlewareMap = {}> {
+    name: string;
+    instanceId?: string;
+    version?: string;
+    imports?: I;
+    requires?: readonly PluginRequirementInput[];
+    meta?: unknown;
+    client?: PluginClientMap<E, I>;
+    ctx?: PluginContextMap<C, I, E>;
+    middlewares?: M;
+    globalMiddlewares?: readonly (keyof M & string)[];
+    options?(current: Readonly<BaseClientOptions>): SeyfertPluginOptions;
+    register?(api: SeyfertPluginApi<M, ExtendOf<I> & E>): void;
+    setup?(client: SeyfertPluginClient & ExtendOf<I> & E, api?: SeyfertPluginApi<M, ExtendOf<I> & E>): Awaitable<void>;
+    teardown?(client: SeyfertPluginClient & ExtendOf<I> & E, api?: SeyfertPluginTeardownApi): Awaitable<void>;
+}
+export interface PluginDiagnostics {
+    name: string;
+    instanceId?: string;
+    index: number;
+    status: PluginLifecycleStatus;
+    imports: readonly string[];
+    clientKeys: readonly string[];
+    ctxKeys: readonly string[];
+    commands: number;
+    components: number;
+    modals: number;
+    events: readonly string[];
+    anyEvents: number;
+    eventErrors: number;
+    middlewares: readonly string[];
+    requirements: readonly PluginRequirementDiagnostic[];
+    shared: readonly string[];
+    cacheResources: readonly string[];
+    langs: readonly string[];
+    hooks: readonly string[];
+    restObservers: number;
+    commandObservers: number;
+    autocompleteWrappers: number;
+    gatewayIntents: number;
+    gatewaySendPayloadWrappers: number;
+    gatewayDispatchInterceptors: number;
+    handlerCreators: number;
+    handlerTransformers: number;
+    messages: readonly PluginDiagnosticMessage[];
+    truncated?: Readonly<Record<string, number>>;
+}
+export {};

package/lib/client/plugins/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginOrder = void 0;
+var PluginOrder;
+(function (PluginOrder) {
+    PluginOrder["Before"] = "before";
+    PluginOrder["After"] = "after";
+})(PluginOrder || (exports.PluginOrder = PluginOrder = {}));