declare const PARSER_NAMES: {
    readonly default: "default";
    readonly fileOnly: "fileOnly";
    readonly codeOnly: "codeOnly";
    readonly Parser_A: "Parser_A";
};

type IParserNames = keyof typeof PARSER_NAMES | "custom";

type IOptions = {
    generation: IGenerationOptions;
    transformation?: ITransformationOptions;
    parser?: IParserOptions;
    debug?: IDebugOptions;
    __meta?: IMeta;
};
type IGenerationOptions = {
    inputDir: string;
    outputDir: string;
    ignore?: string[];
};
type ITransformationOptions = {
    prefix?: string;
    static?: IStaticWordTransformationOption[];
    ignore?: string[];
    pool?: string | string[];
};
type IDebugOptions = {
    stats?: boolean;
    ignoredWarnings?: IDebugIgnoredWarningsOption;
};
type IParserOptions = {
    name: IParserNames;
    regexList?: IParserRegexOption[];
};
type IParserRegexOption = {
    value: string;
    name: string;
};
type IStaticWordTransformationOption = {
    from: string;
    to: string;
};
type IMeta = {
    projectName: string;
    rc: {
        version: string;
        generatedBy: string;
        generatedAt: string;
    };
};
type IDebugIgnoredWarningsOption = "all" | string[];

type IInternalOptions = {
    generation: IInternalGenerationOptions;
    transformation: IInternalTransformationOptions;
    parser: IInternalParserOptions;
    debug: IInternalDebugOptions;
};
type IInternalGenerationOptions = {
    inputDir: string;
    outputDir: string;
    ignore: string[];
};
type IInternalTransformationOptions = {
    prefix: string;
    static: IInternalStaticWordTransformationOption[];
    ignore: string[];
    pool: string[];
};
type IInternalDebugOptions = {
    stats: boolean;
    ignoredWarnings: IDebugIgnoredWarningsOption;
};
type IInternalResponse<T> = {
    error?: {
        errorCode: string;
        errorDescription: string;
    };
    data?: T;
};
type IInternalParserOptions = {
    name: string;
    regexList: IInternalRegexOption[];
};
type IInternalRegexOption = {
    name: string;
    regex: RegExp;
};
type IInternalStaticWordTransformationOption = {
    from: string;
    to: string;
};

declare function buildTransformationOptions(transformationOptions?: ITransformationOptions): IInternalTransformationOptions;
declare function buildParserOptions(parser?: IParserOptions): IInternalResponse<IInternalParserOptions>;
declare function buildDebugOptions(debugOptions?: IDebugOptions): IInternalDebugOptions;

declare function startCLI(): void;

type IRuntimeOptions = {
    map: Record<string, string>;
    processed: {
        map: Record<string, IMapProcessed>;
    };
};
declare function buildRuntimeOptions(): IRuntimeOptions;
declare enum WordEncryptionType {
    default = 0,
    ignore = 1,
    static = 2,
    pool = 3
}
type IMapProcessed = {
    count: number;
    target: string;
    type?: WordEncryptionType;
};

declare function obfuscate(code: string, transformationOptions: IInternalTransformationOptions, parserOptions: IInternalParserOptions, runtimeOptions: IRuntimeOptions): string;

type IStatsOptions = {
    stats: boolean;
};
declare function stats(options: IStatsOptions, runtimeOptions: IRuntimeOptions): void;

export { type IDebugOptions as ICodefendDebugOptions, type IGenerationOptions as ICodefendGenerationOptions, type IOptions as ICodefendGlobalOptions, type IInternalDebugOptions as ICodefendInternalDebugOptions, type IInternalGenerationOptions as ICodefendInternalGenerationOptions, type IInternalOptions as ICodefendInternalGlobalOptions, type IInternalParserOptions as ICodefendInternalParserOptions, type IInternalTransformationOptions as ICodefendInternalTransformationOptions, type IParserOptions as ICodefendParserOptions, type IParserRegexOption as ICodefendParserRegexOption, type IStaticWordTransformationOption as ICodefendStaticWordTransformationOption, type ITransformationOptions as ICodefendTransformationOptions, buildDebugOptions, buildParserOptions, buildRuntimeOptions, buildTransformationOptions, obfuscate, startCLI, stats };