@babel/plugin-transform-export-namespace-from

import plugin from "@babel/plugin-transform-export-namespace-from";

const plugin = require("@babel/plugin-transform-export-namespace-from");

{
  "plugins": ["@babel/plugin-transform-export-namespace-from"]
}

module.exports = {
  plugins: [
    ["@babel/plugin-transform-export-namespace-from", {}]
  ]
};

export * as foo from "bar";
export * as default from "foo";
export * as "some exports" from "baz";

import * as _foo from "bar";
export { _foo as foo };
import * as _default from "foo";
export { _default as default };
import * as _someExports from "baz";
export { _someExports as "some exports" };

/**
 * Babel plugin factory function that returns a plugin configuration object
 * Asserts minimum Babel version 7 using REQUIRED_VERSION global function
 * Conditionally includes parser options based on BABEL_8_BREAKING environment variable
 * @param api - Babel plugin API providing version assertion and utilities
 * @returns Plugin configuration object with name, visitor, and optional parser options
 */
export default function(api: PluginAPI): PluginObj;

interface PluginAPI {
  /** Assert that Babel version meets the minimum required version */
  assertVersion(version: number | string): void;
}

interface PluginObj {
  name: string;
  manipulateOptions?: (opts: any, parser: any) => void;
  visitor: {
    [key: string]: (path: NodePath<any>) => void;
  };
}

interface PluginConfiguration {
  /** Plugin identifier name */
  name: "transform-export-namespace-from";
  
  /** Optional parser configuration function (undefined when BABEL_8_BREAKING is true) */
  manipulateOptions?: (opts: any, parser: ParserConfig) => void;
  
  /** AST visitor methods for transformation */
  visitor: {
    ExportNamedDeclaration(path: NodePath<ExportNamedDeclaration>): void;
  };
}

interface ParserConfig {
  plugins: string[];
}

/**
 * Transforms ExportNamedDeclaration nodes containing ExportNamespaceSpecifier
 * Handles complex cases including ExportDefaultSpecifier and mixed specifier scenarios
 * Converts export namespace declarations into separate import and export statements
 * Generates unique identifiers and preserves remaining specifiers when present
 * @param path - Babel AST node path for ExportNamedDeclaration
 */
ExportNamedDeclaration(path: NodePath<ExportNamedDeclaration>): void;

// From @babel/core
import { types as t } from "@babel/core";

// Core Babel types used in the plugin
interface NodePath<T> {
  node: T;
  scope: Scope;
  replaceWithMultiple(nodes: any[]): any[];
}

interface Scope {
  generateUidIdentifier(name: string): Identifier;
  registerDeclaration(path: any): void;
}

interface ExportNamedDeclaration {
  specifiers: (ExportSpecifier | ExportNamespaceSpecifier | ExportDefaultSpecifier)[];
  source: StringLiteral | null;
}

interface ExportNamespaceSpecifier {
  type: "ExportNamespaceSpecifier";
  exported: Identifier | StringLiteral;
}

interface ExportDefaultSpecifier {
  type: "ExportDefaultSpecifier";
  exported: Identifier;
}

interface ExportSpecifier {
  type: "ExportSpecifier";
  local: Identifier;
  exported: Identifier | StringLiteral;
}

interface ImportDeclaration {
  specifiers: ImportSpecifier[];
  source: StringLiteral;
}

interface ImportNamespaceSpecifier {
  type: "ImportNamespaceSpecifier";
  local: Identifier;
}

interface ImportSpecifier {
  type: "ImportSpecifier";
  local: Identifier;
  imported: Identifier | StringLiteral;
}

interface Identifier {
  type: "Identifier";
  name: string;
}

interface StringLiteral {
  type: "StringLiteral";
  value: string;
}

// Required for plugin factory creation
import { declare } from "@babel/helper-plugin-utils";

// Global function available in Babel build environment
declare function REQUIRED_VERSION(version: number): number | string;
declare function REQUIRED_VERSION(version: string): string;