type EmmettPluginConfig = {
    name: string;
    register: EmmettPluginRegistration[];
} | string;
type EmmettPluginType = 'cli';
type EmmettCliPluginRegistration = {
    pluginType: 'cli';
    path?: string;
};
type EmmettPluginRegistration = EmmettCliPluginRegistration;
type EmmettCliCommand = {
    addCommand<CliCommand>(command: CliCommand): CliCommand;
};
type EmmettCliPlugin = {
    pluginType: 'cli';
    name: string;
    registerCommands: (program: EmmettCliCommand) => Promise<void> | void;
};
type EmmettPlugin = EmmettCliPlugin;
declare const isPluginConfig: (plugin: Partial<EmmettPluginConfig> | string | undefined) => plugin is EmmettPluginConfig;

type EmmettPluginsConfig = {
    plugins: EmmettPluginConfig[];
};

type ErrorConstructor<ErrorType extends Error> = new (...args: any[]) => ErrorType;
declare const isErrorConstructor: <ErrorType extends Error>(expect: Function) => expect is ErrorConstructor<ErrorType>;
declare class EmmettError extends Error {
    static readonly Codes: {
        ValidationError: number;
        IllegalStateError: number;
        NotFoundError: number;
        ConcurrencyError: number;
        InternalServerError: number;
    };
    errorCode: number;
    constructor(options?: {
        errorCode: number;
        message?: string;
    } | string | number);
    static mapFrom(error: Error | {
        message?: string;
        errorCode?: number;
    }): EmmettError;
    static isInstanceOf<ErrorType extends EmmettError = EmmettError>(error: unknown, errorCode?: (typeof EmmettError.Codes)[keyof typeof EmmettError.Codes]): error is ErrorType;
}
declare class ConcurrencyError extends EmmettError {
    current: string | undefined;
    expected: string;
    constructor(current: string | undefined, expected: string, message?: string);
}
declare class ConcurrencyInMemoryDatabaseError extends EmmettError {
    constructor(message?: string);
}
declare class ValidationError extends EmmettError {
    constructor(message?: string);
}
declare class IllegalStateError extends EmmettError {
    constructor(message?: string);
}
declare class NotFoundError extends EmmettError {
    constructor(options?: {
        id: string;
        type: string;
        message?: string;
    });
}

export { ConcurrencyError as C, type EmmettPluginsConfig as E, IllegalStateError as I, NotFoundError as N, ValidationError as V, EmmettError as a, type EmmettPluginType as b, type EmmettPlugin as c, type EmmettCliPlugin as d, type ErrorConstructor as e, type EmmettPluginConfig as f, type EmmettCliPluginRegistration as g, type EmmettPluginRegistration as h, type EmmettCliCommand as i, isPluginConfig as j, isErrorConstructor as k, ConcurrencyInMemoryDatabaseError as l };