@kotori-bot/core/lib/decorators/utils.d.ts

Kotori Core

import 'reflect-metadata';
import { type EventsList, type ModuleConfig } from 'fluoro';
import { type Constructor, Parser } from 'tsukiko';
import type { Context } from '../app';
import { Symbols } from '../global';
import type { CommandConfig } from '../types';
import type { KotoriPlugin } from './plugin';
declare module '../types/events' {
    interface EventsMapping {
        literal_ready_module_decorator(name: string, config: ModuleConfig): void;
    }
}
interface EventOption {
    type: keyof EventsList;
    isOnce?: boolean;
}
interface CommandOption extends Omit<CommandConfig, 'action'> {
    template: string;
    options?: [string, string][];
}
interface MidwareOption {
    priority?: number;
}
interface RegexpOption {
    match: RegExp;
}
type TaskOption = Exclude<Parameters<Context['task']>[0], string>;
type Fn = (...args: any[]) => any;
interface PluginMetaAll {
    name: string;
    lang?: string;
    inject: string[];
    schema?: Parser<object>;
    events: [Fn, EventOption, boolean][];
    midwares: [Fn, MidwareOption, boolean][];
    commands: [Fn, CommandOption, boolean][];
    regexps: [Fn, RegexpOption, boolean][];
    tasks: [Fn, TaskOption, boolean][];
}
type KotoriPluginChild = new (...args: ConstructorParameters<typeof KotoriPlugin>) => KotoriPlugin;
export declare class Decorators {
    static [Symbols.decorator]: Map<string, KotoriPluginChild>;
    static getMeta(target: object | string): PluginMetaAll | undefined;
    static setup(ctx: Context): void;
    static load(ctx: Context, target: string | Constructor, config: ModuleConfig): boolean;
    private readonly pkgName;
    private error;
    private getMeta;
    constructor(pkgName: string);
    readonly import: (target: object) => void;
    readonly lang: <T extends object>(target: T, name: keyof T) => void;
    readonly inject: <T extends object>(target: T, name: keyof T) => void;
    readonly schema: <T extends object>(target: T, name: keyof T) => void;
    on(options: EventOption): <T extends object>(target: T, key: keyof T) => void;
    midware(options?: MidwareOption): <T extends object>(target: T, key: keyof T) => void;
    command(options: CommandOption): <T extends object>(target: T, key: keyof T) => void;
    regexp(options: RegexpOption): <T extends object>(target: T, key: keyof T) => void;
    task(options: TaskOption): <T extends object>(target: T, key: keyof T) => void;
}
export default Decorators;