type collectBundleMetadata =(
    {
        type: BundleType;
        name: string;
        namespace: string;
        namespaceMapping: NamespaceMapping;
        files: {
            fileName: string;
            source: string;
        }[];
    }
) => BundleMetadata;

type collectTemplateMetadata =(
    filename: string;
    source: string;
    namespaceMapping: NamespaceMapping;
) => HTMLTemplateFile;

/** Experimental API, reusing existing ast from @lwc/template-compiler **/
import { IRElement} from '@lwc/template-compiler';
type collectTemplateMetadata =(
    filename: string;
    root: IRElement;
    namespaceMapping: NamespaceMapping;
) => HTMLTemplateFile;
/** End Experimental API **/

type collectScriptMetadata =(
    filename: string;
    source: string;
    namespaceMapping: NamespaceMapping;
    bundleType: BundleType;
) => ScriptFile;

/** Internal API, optimization to reuse existing ast from compilation process **/
import { File } from '@babel/types';
type collectScriptMetadata =(
    filename: string;
    astRoot: File;
    namespaceMapping: NamespaceMapping;
    bundleType: BundleType;
) => ScriptFile;
/** End internal API **/

type collectCssMetadata =(
    filename: string;
    source: string;
    namespaceMapping: NamespaceMapping;
) => CSSFile;

/** Internal API, optimization to reuse existing ast from compilation process **/
import { Root } from 'postcss';
type collectCssMetadata =(
    filename: string;
    root: Root;
    namespaceMapping: NamespaceMapping;
) => CSSFile;
/** End internal API **/

interface BundleMetadata {
    version: string;
    // Full canonical name in camel case
    moduleSpecifier: string;
    name: string;
    namespace: string;
    // main entry file of the bundle
    entryFileName?: string;
    // A list of metadata objects for each file processed in the bundle
    files: (HTMLTemplateFile | ScriptFile | CSSFile)[];
    // Diagnostic issues discovered at the bundle level. Diagnostics discovered at the file level as
    // available in the metadata of the individual file
    diagnostics: CompilerDiagnostic[];
}

// Root metadata object for an HTML template file
interface HTMLTemplateFile extends File {
    fileType: 'html';
    // List of unique components referenced in the template
    componentReferences: ComponentReference[];
    // A strigified version of template in AST format starting with the root <template> node.
    // Note: this is a partial AST
    experimentalAST?: string;
}

// Represents a component referenced in the template.
// Use the 'tagName' property for kebab case and 'name' property for the reference in canonical form
interface ComponentReference {
    // Full canonical name, eg. lightning/input, lightning/recordForm
    // name will be in camel case
    name: string;
    // If a namespace mapping was specified, name will be transformed
    namespacedName?: string;
    // Components are always imported from an external bundle
    type: 'external';
    // element's tag name as it appears in the template, retains the kebab casing
    tagName: string;
    locations: SourceLocation[];
}

// Root Metadata object for a file authored in javascript(or its variants like TypeScript) in an LWC bundle.
interface ScriptFile extends File {
    fileType: 'js';

    // A list of ModuleReference objects referenced by this script file
    moduleReferences: ModuleReference[];

    // List of class metadata, covers only component class and any exported class.
    // class has to be created using the ES6 'class' syntax
    classes: Class[];

    /**
     * If the file has uses an "export default <ClassDeclaration | Identifier that resolved to a local class>",
     * this property provides a reference to the class metadata.
     */
    mainClass?: {
        name?: string;
        refId: ID; // back pointer to the Class metadata
    };

    // Static import statements in a javascript module.
    imports: Import[];

    // Dynamic import statements in a javascript module, additionally information about hints if provided.
    dynamicImports: DynamicImport[];

    // Exports of local bindings
    exports: Export[];

    // DOM Event objects instantiated in a module. Includes Events and CustomEvents.
    domEvents: DOMEvent[];

    // Programmatically added event listeners in a module
    eventListeners: ProgrammaticEventListener[];

    // EventTarget.dispatchEvent invocations
    eventsDispatched: EventDispatch[];
}

// Information about a class
interface Class {
    // Is optional because class can be anonymous
    name?: string;

    // A class is considered a component class if it extends
    // 'LightningElement' class available in the standard 'lwc' module.
    isComponentClass?: boolean;

    // A parent can be another class declared locally, imported identifier from an external module.
    // When not statically analyzable, will be 'unresolved'(e.g. Mixin)
    extends?: ParentClass;

    properties: ClassProperty[];

    methods: ClassMethod[];

    // Location starts with the "class" key word and ends at the closing curly braces of the class body
    location: SourceLocation;
    id: ID;
}

// Information about a class property of a component class.
interface ClassProperty {
    type: 'Property';
    name: string;
    // To make it easy to discover
    propertyType: 'accessor' | 'dataProperty';
    // True, if the property is an instance property
    dataProperty?: DataProperty;
    // Preset if the property has a getter
    getter?: Getter;
    // Present if the property has a setter
    setter?: Setter;
    decorators: LwcDecorator[];
}

// The naming is derived from data descriptors v/s accessor descriptor
interface DataProperty {
    // If the initial value is not statically analyzable, type will be 'unresolved'
    initialValue: Value;
    // Location starts with the first character of the member's identifier and ends at the semi-colon
    location: SourceLocation;
}

// Information about presence of getter
interface Getter {
    // If the initial value is not statically analyzable, type will be 'unresolved'
    initialValue: Value;
    location: SourceLocation;
}

// Information about presence of setter
// Do not infer any information about return value, setters are expected to return void
interface Setter {
    location: SourceLocation;
}

// Information about a class method
interface ClassMethod {
    type: 'Method';
    name: string;
    decorators: LwcDecorator[];
    location: SourceLocation;
}

interface Decorator {
    type: string;
    location: SourceLocation;
}

// Information about the usage of an '@api' decorator to designate a class member as public.
interface ApiDecorator extends Decorator {
    type: 'Api';
}

// Information about an @track decorator usage.
interface TrackDecorator extends Decorator {
    type: 'Track';
}

// Information about @wire decorator usage includes information about the data source.
interface WireDecorator extends Decorator {
    type: 'Wire';
    adapterId: string;
    // module name in canonical form
    adapterModule?: string;
    adapterConfig?: {
        // Configuration where a value is prefixed with '$' to reference a property on the component instance
        reactive: { [name: string]: string };
        // Configuration where value is a static
        static: {
            [name: string]: Value;
        };
    };
}

type LwcDecorator = ApiDecorator | TrackDecorator | WireDecorator;

interface UnresolvedValue {
    type: 'Unresolved';
    value: 'unresolved';
}

interface NumberValue {
    type: 'Number';
    value: number;
}

interface BooleanValue {
    type: 'Boolean';
    value: boolean;
}

interface StringValue {
    type: 'String';
    value: string;
}

interface NullValue {
    type: 'Null';
    value: null;
}

interface UndefinedValue {
    type: 'Undefined';
    value: undefined;
}

interface ObjectValue {
    type: 'Object';
    value: {
        [name: string]: Value;
    };
}

interface ArrayValue {
    type: 'Array';
    value: Value[];
}

interface ImportedValue {
    type: 'ImportedValue';
    localName: string;
    importedName: string;
    moduleSpecifier: string;
}

type Value =
    | BooleanValue
    | StringValue
    | NullValue
    | ObjectValue
    | ArrayValue
    | UndefinedValue
    | NumberValue
    | UnresolvedValue
    | ImportedValue;

// Information about a static import statement in a module.
interface Import {
    defaultBinding?: DefaultBinding;
    namedImports?: NamedImport[];
    namespaceImport?: NameSpaceImport;
    // module name in canonical form
    moduleSpecifier: string;
    // Location starts from the import key word to the end of statement
    location: SourceLocation;
    refId: ID; // back reference to the ModuleReference object
}

// Represents a Default import binding
// e.g: import defaultExport from "module-name";
interface DefaultBinding {
    // The import name will reflect the imported binding's local name
    name: string;
    location: SourceLocation;
}

// e.g: import { export1 as alias1 } from "module-name";
interface NamedImport {
    name: string;
    aliasName?: string;
    location: SourceLocation;
}

// For bindings in import statement like 'import * as name from "module-name";'
// This object captures information about the '* as name'
interface NameSpaceImport {
    aliasName: string;
    location: SourceLocation;
}

// Information about a dynamic import statement in a module.
interface DynamicImport {
    // module name in canonical form
    moduleSpecifier: string;
    refId: ID; // back reference to the ModuleReference object
    moduleNameType: 'string' | 'unresolved';
    location: SourceLocation;
    hints: DynamicImportHint[];
}

interface DynamicImportHint {
    // Hint value with leading and trailing spaces of hint phrase trimmed
    rawValue: string;
    key: string;
    value: string;
    location: SourceLocation;
}

// Information about a export statement in a module.
interface Export {
    namedExports?: NamedExport[];
    defaultExport?: DefaultExport;
    location: SourceLocation;
    // module name in canonical form
    moduleSpecifier?: string;
    // back reference to the ModuleReference object
    refId?: ID;
}

// Information about a export statement in a module.
// e.g. export let name1, name2, …, nameN;
//      export { variable1 as name1, variable2 as name2, …, nameN };
interface NamedExport {
    localName?: string;
    // exported name of the binding
    exportedName: string;
    location: SourceLocation;
}

// A default export
// e.g. export default function (…) { … }
interface DefaultExport {
    location: SourceLocation;
}

// Information about a dom event instantiated in script.
interface DOMEvent {
    eventType: string;
    interface: 'Event' | 'CustomEvent';
    options?: {
        bubbles?: boolean;
        composed?: boolean;
    };
    location: SourceLocation;
    id: ID;
}

// Information about an event handled declaratively in the template.
interface ProgrammaticEventListener {
    type: string;
    targetType: 'host' | 'shadowRoot' | 'document' | 'window' | 'unresolved';
    options?: {
        capture?: boolean;
    };
    location: SourceLocation;
}

interface EventDispatch {
    targetType: 'host' | 'shadowRoot' | 'document' | 'window' | 'unresolved';
    event:
        | {
              refId: ID; // Back pointer to the metadata for the DOMEvent
          }
        | 'unresolved';
    location: SourceLocation;
}

// A parent component class including the 'LightningElement' class provided by the lwc module.
type ParentClass =
    | {
          name: string; // Another class declared in the same file
          refId?: ID; // Back pointer to the metadata for the parent class, if its metadata exists
          location: SourceLocation;
      }
    // or a class imported from an external module
    | {
          // Parent class name. This could be the aliased import binding, use the module specifier
          // refId to check the name of the binding in the source module
          name: string;
          moduleSpecifier: string;
          refId: ID; // Back pointer to the metadata for external module reference
          location: SourceLocation;
      }
    | 'unresolved'; // When the parent class is not statically analyzable, for example mixins

type SfdcResourceType =
    | 'accessCheck'
    | 'apex'
    | 'apexMethod'
    | 'apexContinuation'
    | 'client'
    | 'community'
    | 'component'
    | 'contentAssetUrl'
    | 'customPermission'
    | 'dynamicComponent'
    | 'messageChannel'
    | 'i18n'
    | 'gate'
    | 'label'
    | 'metric'
    | 'internal'
    | 'resourceUrl'
    | 'schema'
    | 'slds'
    | 'user'
    | 'userPermission';

// Information about a module reference
interface ModuleReference {
    // Full canonical name, eg. lightning/input, lightning/recordForm
    // name will be in camel case
    name: string;
    // If a namespace mapping was specified, name will be transformed
    namespacedName?: string;
    // Only present for salesforce scoped modules, else property is omitted
    sfdcResource?: {
        scoped: SfdcResourceType;
        namespacedId?: string; // scoped module namespace normalization
        id?: string;
    };
    type:
        | 'lwc' // reference is the built-in lwc module
        | '@salesforce' // reference is a @salesforce scoped module
        | 'local' // reference is relative import, "local" to the current bundle
        | 'external'; // reference is an external module like another component or a library
    locations: SourceLocation[];
    id: ID;
}

// Unique identifier per object, other metadata objects of the same module can have a back reference
// to this id. The uniqueness of ids is only guaranteed within the module. It cannot span multiple modules
type ID = string;

/**
 * Root metadata object for a css file.
 */
interface CSSFile extends File {
    fileType: 'css';

    // The list of imported CSS modules via the @import CSS at-rule.
    imports: ModuleReference[];

    // The list of CSS custom properties.
    customProperties: CSSCustomProperty[];
}

/**
 * CSS custom property detail.
 */
interface CSSCustomProperty {
    // The custom property name.
    name: string;

    // The custom property location.
    location: SourceLocation;
}

interface BundleMetadata {
    success: boolean;
    version: string;
    diagnostics: Array<Diagnostic>;
    entry: string;
    results: { [name: string]: FileMetadata } // metadata for each source
    interface: BundleInterface; // public methods, events, css properties, exports, slots.
}

interface Diagnostic {
    message: string;
    code: number;
    filename?: string;
    location?: Location;
    level: DiagnosticLevel;
}

enum DiagnosticLevel { Fatal, Error, Warning, Log }

// A bundle interface; which contains a union of all file-based
// metadata objects with some wits about inheritance and overrides. 
interface BundleInterface {
    type: 'module' | 'component';
    eventListener: Array<EventListener>;
    emittedEvents: Array<ClassEvent>;
    publicProperties: Array<ClassMember>;
    publicMethods: Array<ClassMember>;
    slots: Array<SlotMeta>;
    exports: Array<ClassMetadata | FunctionMetadata | VariableMetadata>
}