import * as _babel_generator from '@babel/generator';
import _babel_generator__default, { GeneratorOptions as GeneratorOptions$1, GeneratorResult as GeneratorResult$1 } from '@babel/generator';
export { default as generate } from '@babel/generator';
import * as _babel_traverse from '@babel/traverse';
import _babel_traverse__default, { VisitWrapper, Visitor as Visitor$1, NodePath, Scope, HubInterface } from '@babel/traverse';
export { NodePath, Scope, default as traverse } from '@babel/traverse';
import * as t from '@babel/types';
export { t as types };
import { SourceMapConverter } from 'convert-source-map';
import { Targets, InputTargets } from '@babel/helper-compilation-targets';
import gensync, { Handler } from 'gensync';
import { ParserOptions, parse as parse$1, ParseResult, tokTypes } from '@babel/parser';
export { tokTypes } from '@babel/parser';
import template from '@babel/template';
export { default as template } from '@babel/template';

type ___CallerMetadata = CallerMetadata;
type ___ConfigAPI = ConfigAPI;
type ___ConfigItem<API> = ConfigItem<API>;
declare const ___ConfigItem: typeof ConfigItem;
declare const ___DEFAULT_EXTENSIONS: typeof DEFAULT_EXTENSIONS;
type ___File = File;
declare const ___File: typeof File;
type ___FileResult = FileResult;
type ___GeneratorOptions = GeneratorOptions;
type ___GeneratorResult = GeneratorResult;
type ___InputOptions = InputOptions;
declare const ___NodePath: typeof NodePath;
type ___NormalizedOptions = NormalizedOptions;
type ___PartialConfig = PartialConfig;
declare const ___PartialConfig: typeof PartialConfig;
type ___PluginAPI = PluginAPI;
type ___PluginItem<Option = object> = PluginItem<Option>;
type ___PluginObject<S extends PluginPass = PluginPass> = PluginObject<S>;
type ___PluginPass<Options = object> = PluginPass<Options>;
declare const ___PluginPass: typeof PluginPass;
type ___PluginTarget<Option = object> = PluginTarget<Option>;
type ___PresetAPI = PresetAPI;
type ___PresetItem<Option = object> = PresetItem<Option>;
type ___PresetObject = PresetObject;
type ___PresetTarget<Option = object> = PresetTarget<Option>;
declare const ___Scope: typeof Scope;
type ___Visitor<S = unknown> = Visitor<S>;
type ___VisitorBase<S = unknown> = VisitorBase<S>;
declare const ___createConfigItem: typeof createConfigItem;
declare const ___createConfigItemAsync: typeof createConfigItemAsync;
declare const ___createConfigItemSync: typeof createConfigItemSync;
declare const ___getEnv: typeof getEnv;
declare const ___loadOptions: typeof loadOptions;
declare const ___loadOptionsAsync: typeof loadOptionsAsync;
declare const ___loadOptionsSync: typeof loadOptionsSync;
declare const ___loadPartialConfig: typeof loadPartialConfig;
declare const ___loadPartialConfigAsync: typeof loadPartialConfigAsync;
declare const ___loadPartialConfigSync: typeof loadPartialConfigSync;
declare const ___parse: typeof parse;
declare const ___parseAsync: typeof parseAsync;
declare const ___parseSync: typeof parseSync;
declare const ___resolvePlugin: typeof resolvePlugin;
declare const ___resolvePreset: typeof resolvePreset;
declare const ___template: typeof template;
declare const ___tokTypes: typeof tokTypes;
declare const ___transform: typeof transform;
declare const ___transformAsync: typeof transformAsync;
declare const ___transformFile: typeof transformFile;
declare const ___transformFileAsync: typeof transformFileAsync;
declare const ___transformFileSync: typeof transformFileSync;
declare const ___transformFromAst: typeof transformFromAst;
declare const ___transformFromAstAsync: typeof transformFromAstAsync;
declare const ___transformFromAstSync: typeof transformFromAstSync;
declare const ___transformSync: typeof transformSync;
declare const ___version: typeof version;
declare namespace __ {
  export { type ___CallerMetadata as CallerMetadata, type ___ConfigAPI as ConfigAPI, ___ConfigItem as ConfigItem, ___DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS, ___File as File, type ___FileResult as FileResult, type ___GeneratorOptions as GeneratorOptions, type ___GeneratorResult as GeneratorResult, type ___InputOptions as InputOptions, ___NodePath as NodePath, type ___NormalizedOptions as NormalizedOptions, ___PartialConfig as PartialConfig, type ___PluginAPI as PluginAPI, type ___PluginItem as PluginItem, type ___PluginObject as PluginObject, ___PluginPass as PluginPass, type ___PluginTarget as PluginTarget, type ___PresetAPI as PresetAPI, type ___PresetItem as PresetItem, type ___PresetObject as PresetObject, type ___PresetTarget as PresetTarget, ___Scope as Scope, type ___Visitor as Visitor, type ___VisitorBase as VisitorBase, export_default as buildExternalHelpers, ___createConfigItem as createConfigItem, ___createConfigItemAsync as createConfigItemAsync, ___createConfigItemSync as createConfigItemSync, _babel_generator__default as generate, ___getEnv as getEnv, ___loadOptions as loadOptions, ___loadOptionsAsync as loadOptionsAsync, ___loadOptionsSync as loadOptionsSync, ___loadPartialConfig as loadPartialConfig, ___loadPartialConfigAsync as loadPartialConfigAsync, ___loadPartialConfigSync as loadPartialConfigSync, ___parse as parse, ___parseAsync as parseAsync, ___parseSync as parseSync, ___resolvePlugin as resolvePlugin, ___resolvePreset as resolvePreset, ___template as template, ___tokTypes as tokTypes, ___transform as transform, ___transformAsync as transformAsync, ___transformFile as transformFile, ___transformFileAsync as transformFileAsync, ___transformFileSync as transformFileSync, ___transformFromAst as transformFromAst, ___transformFromAstAsync as transformFromAstAsync, ___transformFromAstSync as transformFromAstSync, ___transformSync as transformSync, _babel_traverse__default as traverse, t as types, ___version as version };
}

declare const __marker: unique symbol;
type ReadonlyDeepArray<T> = readonly (T | ReadonlyDeepArray<T>)[] & {
    [__marker]: true;
};

type SimpleCacheConfigurator = {
    (forever: boolean): void;
    <T extends SimpleType>(handler: () => T): T;
    forever: () => void;
    never: () => void;
    using: <T extends SimpleType>(handler: () => T) => T;
    invalidate: <T extends SimpleType>(handler: () => T) => T;
};
type SimpleType = string | boolean | number | null | undefined | Promise<SimpleType>;

type FileHandling = "transpile" | "ignored" | "unsupported";

type EnvName = NonNullable<InputOptions["envName"]>;
type EnvFunction = {
    (): string;
    <T extends SimpleType>(extractor: (envName: EnvName) => T): T;
    (envVar: string): boolean;
    (envVars: string[]): boolean;
};
type CallerFactory = {
    <T extends SimpleType>(extractor: (callerMetadata: CallerMetadata | undefined) => T): T;
    (extractor: (callerMetadata: CallerMetadata | undefined) => unknown): SimpleType;
};
type TargetsFunction = () => Targets;
type AssumptionFunction = (name: AssumptionName) => boolean | undefined;
type ConfigAPI = {
    version: string;
    cache: SimpleCacheConfigurator;
    env: EnvFunction;
    async: () => boolean;
    assertVersion: typeof assertVersion;
    caller: CallerFactory;
};
type PresetAPI$1 = {
    targets: TargetsFunction;
    addExternalDependency: (ref: string) => void;
} & ConfigAPI;
type PluginAPI$1 = {
    assumption: AssumptionFunction;
} & PresetAPI$1;
declare function assertVersion(range: string | number): void;

interface UnloadedDescriptor<API, Options = object | undefined> {
    name: string | undefined;
    value: object | ((api: API, options: Options, dirname: string) => unknown);
    options: Options;
    dirname: string;
    alias: string;
    ownPass?: boolean;
    file?: {
        request: string;
        resolved: string;
    };
}

/**
 * Create a config item using the same value format used in Babel's config
 * files. Items returned from this function should be cached by the caller
 * ideally, as recreating the config item will mean re-resolving the item
 * and re-evaluating the plugin/preset function.
 */
declare function createConfigItem$1<API>(value: PluginItem | PresetItem, { dirname, type, }?: {
    dirname?: string;
    type?: "preset" | "plugin";
}): Handler<ConfigItem<API>>;
declare const CONFIG_ITEM_BRAND: unique symbol;
/**
 * A public representation of a plugin/preset that will _eventually_ be load.
 * Users can use this to interact with the results of a loaded Babel
 * configuration.
 *
 * Any changes to public properties of this class should be considered a
 * breaking change to Babel's API.
 */
declare class ConfigItem<API> {
    /**
     * The private underlying descriptor that Babel actually cares about.
     * If you access this, you are a bad person.
     */
    _descriptor: UnloadedDescriptor<API>;
    /**
     * Used to detect ConfigItem instances from other Babel instances.
     */
    [CONFIG_ITEM_BRAND]: boolean;
    /**
     * The resolved value of the item itself.
     */
    value: object | Function;
    /**
     * The options, if any, that were passed to the item.
     * Mutating this will lead to undefined behavior.
     *
     * "false" means that this item has been disabled.
     */
    options: object | void | false;
    /**
     * The directory that the options for this item are relative to.
     */
    dirname: string;
    /**
     * Get the name of the plugin, if the user gave it one.
     */
    name: string | void;
    /**
     * Data about the file that the item was loaded from, if Babel knows it.
     */
    file: {
        request: string;
        resolved: string;
    } | void;
    constructor(descriptor: UnloadedDescriptor<API>);
}

type AssumptionName = (typeof knownAssumptions)[number];
type Assumptions = {
    [Name in AssumptionName]?: boolean;
};
type EnvSet<T> = Record<string, T>;
type InputOptions = {
    cwd?: string;
    filename?: string;
    filenameRelative?: string;
    babelrc?: boolean;
    babelrcRoots?: BabelrcSearch;
    configFile?: ConfigFileSearch;
    root?: string;
    rootMode?: RootMode;
    code?: boolean;
    ast?: boolean;
    cloneInputAst?: boolean;
    inputSourceMap?: RootInputSourceMapOption;
    envName?: string;
    caller?: CallerMetadata;
    extends?: string;
    env?: EnvSet<InputOptions>;
    ignore?: MatchItem[];
    only?: MatchItem[];
    overrides?: InputOptions[];
    showIgnoredFiles?: boolean;
    test?: ConfigApplicableTest;
    include?: ConfigApplicableTest;
    exclude?: ConfigApplicableTest;
    presets?: PresetItem[];
    plugins?: PluginItem[];
    passPerPreset?: boolean;
    assumptions?: Assumptions;
    targets?: TargetsListOrObject;
    browserslistConfigFile?: ConfigFileSearch;
    browserslistEnv?: string;
    retainLines?: GeneratorOptions$1["retainLines"];
    comments?: GeneratorOptions$1["comments"];
    shouldPrintComment?: GeneratorOptions$1["shouldPrintComment"];
    compact?: GeneratorOptions$1["compact"];
    minified?: GeneratorOptions$1["minified"];
    auxiliaryCommentBefore?: GeneratorOptions$1["auxiliaryCommentBefore"];
    auxiliaryCommentAfter?: GeneratorOptions$1["auxiliaryCommentAfter"];
    sourceType?: SourceTypeOption;
    wrapPluginVisitorMethod?: VisitWrapper | null;
    highlightCode?: boolean;
    sourceMaps?: SourceMapsOption;
    sourceMap?: SourceMapsOption;
    sourceFileName?: string;
    sourceRoot?: string;
    parserOpts?: ParserOptions;
    generatorOpts?: GeneratorOptions$1;
};
type NormalizedOptions = Omit<InputOptions, "presets" | "plugins"> & {
    assumptions: Assumptions;
    targets: Targets;
    cloneInputAst: boolean;
    babelrc: false;
    configFile: false;
    browserslistConfigFile: false;
    passPerPreset: false;
    envName: string;
    cwd: string;
    root: string;
    rootMode: "root";
    filename: string | undefined;
    presets: ConfigItem<PresetAPI>[];
    plugins: ConfigItem<PluginAPI>[];
};
type ResolvedOptions = Omit<NormalizedOptions, "presets" | "plugins" | "passPerPreset"> & {
    presets: {
        plugins: Plugin[];
    }[];
    plugins: Plugin[];
    passPerPreset: boolean;
};
type CallerMetadata = {
    name: string;
    supportsStaticESM?: boolean;
    supportsDynamicImport?: boolean;
    supportsTopLevelAwait?: boolean;
    supportsExportNamespaceFrom?: boolean;
};
type MatchItem = string | RegExp | ((path: string | undefined, context: {
    dirname: string;
    caller: CallerMetadata | undefined;
    envName: string;
}) => unknown);
type MaybeDefaultProperty<T> = T | {
    default: T;
};
type PluginTarget<Option = object> = string | MaybeDefaultProperty<(api: PluginAPI, options: Option, dirname: string) => PluginObject>;
type PluginItem<Option = object> = ConfigItem<PluginAPI> | PluginTarget<Option> | [PluginTarget<Option>, Option] | [PluginTarget<Option>, Option, string];
type PresetTarget<Option = object> = string | MaybeDefaultProperty<(api: PresetAPI, options: Option, dirname: string) => PresetObject>;
type PresetItem<Option = object> = ConfigItem<PresetAPI> | PresetTarget<Option> | [PresetTarget<Option>, Option] | [PresetTarget<Option>, Option, string];
type ConfigApplicableTest = MatchItem | MatchItem[];
type ConfigFileSearch = string | boolean;
type BabelrcSearch = boolean | MatchItem | MatchItem[];
type SourceMapsOption = boolean | "inline" | "both";
type SourceTypeOption = "module" | "commonjs" | "script" | "unambiguous";
interface InputSourceMap {
    version: number;
    sources: string[];
    names: string[];
    sourceRoot?: string | undefined;
    sourcesContent?: string[] | undefined;
    mappings: string;
    file: string;
}
type RootInputSourceMapOption = InputSourceMap | boolean;
type RootMode = "root" | "upward" | "upward-optional";
type TargetsListOrObject = Targets | InputTargets | InputTargets["browsers"];
declare const knownAssumptions: readonly ["arrayLikeIsIterable", "constantReexports", "constantSuper", "enumerableModuleMeta", "ignoreFunctionLength", "ignoreToPrimitiveHint", "iterableIsArray", "mutableTemplateObject", "noClassCalls", "noClassPrototypeAssign", "noConstructorPrimitiveReturn", "noDocumentAll", "noIncompleteNsImportDetection", "noNewArrows", "noUninitializedPrivateFieldAccess", "noUninitializedThis", "objectRestNoSymbols", "privateFieldsAsSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", "setComputedProperties", "setPublicClassFields", "setSpreadProperties", "skipForOfIteratorClosing", "superIsCallableConstructor"];

type PluginObject<S extends PluginPass = PluginPass> = {
    name?: string;
    manipulateOptions?: (options: ResolvedOptions & {
        generatorOpts: GeneratorOptions$1;
    }, parserOpts: ParserOptions & {
        plugins: NonNullable<ParserOptions["plugins"]>;
    }) => void;
    pre?: (this: S, file: File) => void | Promise<void>;
    post?: (this: S, file: File) => void | Promise<void>;
    inherits?: (api: PluginAPI, options: any, dirname: string) => PluginObject;
    visitor?: Visitor$1<S>;
    parserOverride?: (...args: [...Parameters<typeof parse$1>, typeof parse$1]) => ReturnType<typeof parse$1>;
    generatorOverride?: (ast: File["ast"], generatorOpts: GeneratorOptions$1, code: File["code"], generate: typeof _babel_generator__default) => GeneratorResult$1;
};

declare class Plugin {
    key: string | undefined | null;
    manipulateOptions?: PluginObject["manipulateOptions"];
    post?: PluginObject["post"];
    pre?: PluginObject["pre"];
    visitor: PluginObject["visitor"];
    parserOverride?: PluginObject["parserOverride"];
    generatorOverride?: PluginObject["generatorOverride"];
    options: object;
    externalDependencies: ReadonlyDeepArray<string>;
    constructor(plugin: PluginObject, options: object, key?: string, externalDependencies?: ReadonlyDeepArray<string>);
}

declare function loadPartialConfig$1(opts?: InputOptions): Handler<PartialConfig | null>;

declare class PartialConfig {
    /**
     * These properties are public, so any changes to them should be considered
     * a breaking change to Babel's API.
     */
    options: NormalizedOptions;
    babelrc: string | undefined;
    babelignore: string | undefined;
    config: string | undefined;
    fileHandling: FileHandling;
    files: Set<string>;
    constructor(options: NormalizedOptions, babelrc: string | undefined, ignore: string | undefined, config: string | undefined, fileHandling: FileHandling, files: Set<string>);
    /**
     * Returns true if there is a config file in the filesystem for this config.
     */
    hasFilesystemConfig(): boolean;
}

type PluginAPI = PluginAPI$1 & typeof __;
type PresetAPI = PresetAPI$1 & typeof __;

declare const loadPartialConfigRunner: gensync.Gensync<[opts?: InputOptions | undefined], PartialConfig | null, any>;
declare function loadPartialConfigAsync(...args: Parameters<typeof loadPartialConfigRunner.async>): Promise<PartialConfig | null>;
declare function loadPartialConfigSync(...args: Parameters<typeof loadPartialConfigRunner.sync>): PartialConfig | null;
declare function loadPartialConfig(opts: Parameters<typeof loadPartialConfig$1>[0], callback?: (err: Error, val: PartialConfig | null) => void): void;
declare function loadOptionsImpl(opts: InputOptions | null | undefined): Handler<ResolvedOptions | null>;
declare const loadOptionsRunner: gensync.Gensync<[opts: InputOptions | null | undefined], ResolvedOptions | null, any>;
declare function loadOptionsAsync(...args: Parameters<typeof loadOptionsRunner.async>): Promise<ResolvedOptions | null>;
declare function loadOptionsSync(...args: Parameters<typeof loadOptionsRunner.sync>): ResolvedOptions | null;
declare function loadOptions(opts: Parameters<typeof loadOptionsImpl>[0], callback?: (err: Error, val: ResolvedOptions | null) => void): void;
declare const createConfigItemRunner: gensync.Gensync<[value: string | ConfigItem<PresetAPI> | ((api: PresetAPI, options: object, dirname: string) => PresetObject) | {
    default: (api: PresetAPI, options: object, dirname: string) => PresetObject;
} | [PresetTarget<object>, object] | [PresetTarget<object>, object, string] | ConfigItem<PluginAPI> | ((api: PluginAPI, options: object, dirname: string) => PluginObject) | {
    default: (api: PluginAPI, options: object, dirname: string) => PluginObject;
} | [PluginTarget<object>, object] | [PluginTarget<object>, object, string], ({
    dirname?: string;
    type?: "preset" | "plugin";
} | undefined)?], ConfigItem<unknown>, any>;
declare function createConfigItemAsync(...args: Parameters<typeof createConfigItemRunner.async>): Promise<ConfigItem<unknown>>;
declare function createConfigItemSync(...args: Parameters<typeof createConfigItemRunner.sync>): ConfigItem<unknown>;
type CreateConfigItemOptions = Parameters<typeof createConfigItem$1>[1];
type CreateConfigItemCallback = (err: Error | undefined, val: ConfigItem<PluginAPI> | null) => void;
type CreateConfigItem = {
    (target: PluginTarget, callback: CreateConfigItemCallback): void;
    (target: PluginTarget, options: CreateConfigItemOptions, callback: CreateConfigItemCallback): void;
};
declare const createConfigItem: CreateConfigItem;

type NormalizedFile = {
    code: string;
    ast: t.File;
    inputMap: SourceMapConverter | null;
};

declare class File {
    _map: Map<unknown, unknown>;
    opts: ResolvedOptions;
    declarations: Record<string, t.Identifier>;
    path: NodePath<t.Program>;
    ast: t.File;
    scope: Scope;
    metadata: Record<string, any>;
    code: string;
    inputMap: SourceMapConverter | null;
    hub: HubInterface & {
        file: File;
    };
    constructor(options: ResolvedOptions, { code, ast, inputMap }: NormalizedFile);
    /**
     * Provide backward-compatible access to the interpreter directive handling
     * in Babel 6.x. If you are writing a plugin for Babel 7.x or higher, it would be
     * best to use 'program.interpreter' directly.
     */
    get shebang(): string;
    set shebang(value: string);
    set(key: unknown, val: unknown): void;
    get(key: unknown): any;
    has(key: unknown): boolean;
    /**
     * Check if a given helper is available in @babel/core's helper list.
     *
     * This _also_ allows you to pass a Babel version specifically. If the
     * helper exists, but was not available for the full given range, it will be
     * considered unavailable.
     */
    availableHelper(name: string, versionRange?: string | null): boolean;
    addHelper(name: string): t.Identifier;
    _addHelper(name: string): t.Identifier;
    buildCodeFrameError(node: t.Node | undefined | null, msg: string, _Error?: typeof Error): Error;
}

declare class PluginPass<Options = object> {
    _map: Map<unknown, unknown>;
    key: string | undefined | null;
    file: File;
    opts: Partial<Options>;
    /**
     * The working directory that Babel's programmatic options are loaded
     * relative to.
     */
    cwd: string;
    /** The absolute path of the file being compiled. */
    filename: string | undefined;
    /**
     * Is Babel executed in async mode or not.
     */
    isAsync: boolean;
    constructor(file: File, key: string | null | undefined, options: Options | undefined, isAsync: boolean);
    set(key: unknown, val: unknown): void;
    get(key: unknown): any;
    availableHelper(name: string, versionRange?: string | null): boolean;
    addHelper(name: string): t.Identifier;
    buildCodeFrameError(node: t.Node | undefined | null, msg: string, _Error?: typeof Error): Error;
}

declare function export_default(allowlist?: string[], outputType?: "global" | "module" | "umd" | "var"): string;

declare function getEnv(defaultValue?: string): string;

type FileResultCallback = {
    (err: Error, file: null): void;
    (err: null, file: FileResult | null): void;
};
type FileResult = {
    metadata: Record<string, any>;
    options: Record<string, any>;
    ast: t.File | null;
    code: string | null;
    map: GeneratorResult$1["map"];
    sourceType: Exclude<SourceTypeOption, "unambiguous">;
    externalDependencies: Set<string>;
};

type Transform = {
    (code: string, callback: FileResultCallback): void;
    (code: string, opts: InputOptions | undefined | null, callback: FileResultCallback): void;
};
declare const transformRunner: gensync.Gensync<[code: string, opts?: InputOptions | null | undefined], FileResult | null, any>;
declare const transform: Transform;
declare function transformSync(...args: Parameters<typeof transformRunner.sync>): FileResult | null;
declare function transformAsync(...args: Parameters<typeof transformRunner.async>): Promise<FileResult | null>;

declare const transformFileRunner: gensync.Gensync<[filename: string, opts?: InputOptions | undefined], FileResult | null, any>;
declare function transformFile(filename: string, callback: FileResultCallback): void;
declare function transformFile(filename: string, opts: InputOptions | undefined | null, callback: FileResultCallback): void;
declare function transformFileSync(...args: Parameters<typeof transformFileRunner.sync>): FileResult | null;
declare function transformFileAsync(...args: Parameters<typeof transformFileRunner.async>): Promise<FileResult | null>;

type AstRoot = t.File | t.Program;
type TransformFromAst = {
    (ast: AstRoot, code: string, callback: FileResultCallback): void;
    (ast: AstRoot, code: string, opts: InputOptions | undefined | null, callback: FileResultCallback): void;
};
declare const transformFromAstRunner: gensync.Gensync<[ast: AstRoot, code: string, opts: InputOptions | null | undefined], FileResult | null, any>;
declare const transformFromAst: TransformFromAst;
declare function transformFromAstSync(...args: Parameters<typeof transformFromAstRunner.sync>): FileResult | null;
declare function transformFromAstAsync(...args: Parameters<typeof transformFromAstRunner.async>): Promise<FileResult | null>;

type FileParseCallback = {
    (err: Error, ast: null): void;
    (err: null, ast: ParseResult | null): void;
};
type Parse = {
    (code: string, callback: FileParseCallback): void;
    (code: string, opts: InputOptions | undefined | null, callback: FileParseCallback): void;
};
declare const parseRunner: gensync.Gensync<[code: string, opts: InputOptions | null | undefined], ParseResult | null, any>;
declare const parse: Parse;
declare function parseSync(...args: Parameters<typeof parseRunner.sync>): ParseResult | null;
declare function parseAsync(...args: Parameters<typeof parseRunner.async>): Promise<ParseResult | null>;

declare const version: string;

declare const resolvePlugin: (name: string, dirname: string) => string;
declare const resolvePreset: (name: string, dirname: string) => string;

type Visitor<S = unknown> = _babel_traverse.Visitor<S>;
type VisitorBase<S = unknown> = _babel_traverse.VisitorBase<S>;
type GeneratorOptions = _babel_generator.GeneratorOptions;
type GeneratorResult = _babel_generator.GeneratorResult;

type PresetObject = {
    overrides?: PresetObject[];
    test?: ConfigApplicableTest;
    plugins?: PluginItem[];
};

/**
 * Recommended set of compilable extensions. Not used in @babel/core directly, but meant as
 * as an easy source for tooling making use of @babel/core.
 */
declare const DEFAULT_EXTENSIONS: readonly [".js", ".jsx", ".es6", ".es", ".mjs", ".cjs"];

export { type CallerMetadata, type ConfigAPI, ConfigItem, DEFAULT_EXTENSIONS, File, type FileResult, type GeneratorOptions, type GeneratorResult, type InputOptions, type NormalizedOptions, PartialConfig, type PluginAPI, type PluginItem, type PluginObject, PluginPass, type PluginTarget, type PresetAPI, type PresetItem, type PresetObject, type PresetTarget, type Visitor, type VisitorBase, export_default as buildExternalHelpers, createConfigItem, createConfigItemAsync, createConfigItemSync, getEnv, loadOptions, loadOptionsAsync, loadOptionsSync, loadPartialConfig, loadPartialConfigAsync, loadPartialConfigSync, parse, parseAsync, parseSync, resolvePlugin, resolvePreset, transform, transformAsync, transformFile, transformFileAsync, transformFileSync, transformFromAst, transformFromAstAsync, transformFromAstSync, transformSync, version };