import type { RegisteredPluginMiddlewares, SeyfertRegistry } from '../client/plugins';
import type { FlatObjectKeys, PermissionStrings } from '../common';
import { ApplicationCommandType, ApplicationIntegrationType, type EntryPointCommandHandlerType, InteractionContextType, type LocaleString } from '../types';
import type { CommandOption, OptionsRecord, SubCommand } from './applications/chat';
import type { AnyMiddlewareContext, DefaultLocale, ExtraProps, IgnoreCommand } from './applications/shared';
export type RegisteredMiddlewares = SeyfertRegistry extends {
    middlewares: infer M extends Record<string, AnyMiddlewareContext>;
} ? M : {};
export type ResolvedRegisteredMiddlewares = RegisteredMiddlewares & RegisteredPluginMiddlewares;
type MiddlewareKey = keyof ResolvedRegisteredMiddlewares;
export type InferMiddlewares<T extends readonly MiddlewareKey[]> = T[number];
export type CommandDeclareOptions = DecoratorDeclareOptions | (Omit<DecoratorDeclareOptions, 'description'> & {
    type: ApplicationCommandType.User | ApplicationCommandType.Message;
}) | (Omit<DecoratorDeclareOptions, 'ignore' | 'aliases' | 'guildId'> & {
    type: ApplicationCommandType.PrimaryEntryPoint;
    handler: EntryPointCommandHandlerType;
});
export interface DecoratorDeclareOptions {
    name: string;
    description: string;
    botPermissions?: PermissionStrings;
    defaultMemberPermissions?: PermissionStrings;
    guildId?: readonly string[];
    nsfw?: boolean;
    integrationTypes?: (keyof typeof ApplicationIntegrationType)[] | ApplicationIntegrationType[];
    contexts?: (keyof typeof InteractionContextType)[] | InteractionContextType[];
    ignore?: IgnoreCommand;
    aliases?: readonly string[];
    props?: ExtraProps;
}
export declare function Locales({ name: names, description: descriptions, }: {
    name?: [language: LocaleString, value: string][];
    description?: [language: LocaleString, value: string][];
}): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name_localizations: {
            [k: string]: string;
        } | undefined;
        description_localizations: {
            [k: string]: string;
        } | undefined;
    };
} & T;
export declare function LocalesT(name?: FlatObjectKeys<DefaultLocale>, description?: FlatObjectKeys<DefaultLocale>): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        __t: {
            name: undefined;
            description: undefined;
        };
    };
} & T;
export type TranslatedGroupDefinition = {
    name?: FlatObjectKeys<DefaultLocale>;
    description?: FlatObjectKeys<DefaultLocale>;
    defaultDescription: string;
    aliases?: string[];
};
export type LocalizedGroupDefinition = {
    name?: [language: LocaleString, value: string][];
    description?: [language: LocaleString, value: string][];
    defaultDescription: string;
    aliases?: string[];
};
export type GroupDefinition = TranslatedGroupDefinition | LocalizedGroupDefinition;
export type GroupDefinitions = Record<string, LocalizedGroupDefinition> | Record<string, TranslatedGroupDefinition>;
export declare function defineGroups<const T extends Record<string, LocalizedGroupDefinition>>(groups: T): T;
export declare function defineGroups<const T extends Record<string, TranslatedGroupDefinition>>(groups: T): T;
export declare function GroupsT<const T extends Record<string, TranslatedGroupDefinition>>(groups: T): <T_1 extends {
    new (...args: any[]): object;
}>(target: T_1) => {
    new (...args: any[]): {
        __tGroups: T;
        groupsAliases: Record<string, string>;
    };
} & T_1;
export declare function Groups<const T extends Record<string, LocalizedGroupDefinition>>(groups: T): <T_1 extends {
    new (...args: any[]): object;
}>(target: T_1) => {
    new (...args: any[]): {
        groups: T;
        groupsAliases: Record<string, string>;
    };
} & T_1;
type GroupDecorator = <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        group: string;
    };
} & T;
type OptionsDecorator = <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        options: SubCommand[] | CommandOption[];
    };
} & T;
type LowercaseOptionsRecord<T extends OptionsRecord> = T & {
    [K in keyof T as K extends string ? (K extends Lowercase<K> ? never : K) : never]: never;
};
type LowercaseDeclareName<T extends CommandDeclareOptions> = {
    [K in keyof T]: K extends 'name' ? T extends {
        type: ApplicationCommandType.User | ApplicationCommandType.Message;
    } ? T[K] : string extends T[K] ? T[K] : T[K] extends Lowercase<T[K] & string> ? T[K] : Lowercase<T[K] & string> : T[K];
};
export declare function Group(groupName: string): GroupDecorator;
export declare function Group<const T extends GroupDefinitions>(_groupsDef: T, groupName: keyof T & string): GroupDecorator;
export declare function Options(options: (new () => SubCommand)[]): OptionsDecorator;
export declare function Options<const T extends OptionsRecord>(options: LowercaseOptionsRecord<T>): OptionsDecorator;
export declare function AutoLoad(): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        __autoload: boolean;
    };
} & T;
export declare function middlewares<const T extends readonly MiddlewareKey[]>(...cbs: T): T;
export declare function Middlewares(cbs: readonly MiddlewareKey[]): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        middlewares: readonly never[];
    };
} & T;
export declare function Declare<const T extends CommandDeclareOptions>(input: LowercaseDeclareName<T>): <C extends {
    new (...args: any[]): object;
}>(target: C) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & C;
export {};