@teambit/typescript 1.0.228 → 1.0.230

package/dist/cmds/check-types.cmd.d.ts

@@ -0,0 +1,26 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { Logger } from '@teambit/logger';
+import { Workspace } from '@teambit/workspace';
+import { TypescriptMain } from '../typescript.main.runtime';
+export declare class CheckTypesCmd implements Command {
+    private typescript;
+    private workspace;
+    private logger;
+    name: string;
+    description: string;
+    arguments: {
+        name: string;
+        description: string;
+    }[];
+    alias: string;
+    group: string;
+    options: CommandOptions;
+    constructor(typescript: TypescriptMain, workspace: Workspace, logger: Logger);
+    report([pattern]: [string], { all, strict }: {
+        all: boolean;
+        strict: boolean;
+    }): Promise<{
+        code: number;
+        data: string;
+    }>;
+}

package/dist/cmds/write-tsconfig.cmd.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="lodash" />
+import { Command, CommandOptions } from '@teambit/cli';
+import { TypescriptMain } from '../typescript.main.runtime';
+type Flags = {
+    dryRun?: boolean;
+    noDedupe?: boolean;
+    dryRunWithTsconfig?: boolean;
+    clean?: boolean;
+    silent?: boolean;
+};
+export default class WriteTsconfigCmd implements Command {
+    private tsMain;
+    name: string;
+    description: string;
+    alias: string;
+    group: string;
+    private: boolean;
+    options: CommandOptions;
+    constructor(tsMain: TypescriptMain);
+    report(_args: any, flags: Flags): Promise<string>;
+    json(_args: any, flags: Flags): Promise<{
+        cleanResults: string[] | undefined;
+        writeResults: import("lodash").Omit<import("../tsconfig-writer").TsconfigPathsPerEnv, "tsconfig">[];
+    }>;
+}
+export {};

package/dist/compiler-options.d.ts

@@ -0,0 +1,22 @@
+import type { CompilerOptions } from '@teambit/compiler';
+export type TypeScriptCompilerOptions = {
+    /**
+     * tsconfig to use during compilation.
+     */
+    tsconfig: Record<string, any>;
+    /**
+     * path for .d.ts files to include during build.
+     */
+    types: string[];
+    /**
+     * Run the compiler for .js files. this will only affect whether to run the compiler on the files
+     * or not. It won't change the tsconfig to support or not support js files.
+     */
+    compileJs?: boolean;
+    /**
+     * Run the compiler for .js files. this will only affect whether to run the compiler on the files
+     * or not. It won't change the tsconfig to support or not support jsx files.
+     */
+    compileJsx?: boolean;
+} & Partial<CompilerOptions>;
+export type TsCompilerOptionsWithoutTsConfig = Omit<TypeScriptCompilerOptions, 'tsconfig'>;

package/dist/dedupe-path.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export { TransformerNotFound } from './transformer-not-found';

package/dist/exceptions/transformer-not-found.d.ts

@@ -0,0 +1,8 @@
+import { Node } from 'typescript';
+import { Component } from '@teambit/component';
+import { Location } from '@teambit/semantics.entities.semantic-schema';
+export declare class TransformerNotFound extends Error {
+    readonly node: Node;
+    readonly component: Component;
+    constructor(node: Node, component: Component, location: Location);
+}

package/dist/export-identifier.d.ts

@@ -0,0 +1,6 @@
+import { Identifier } from './identifier';
+export declare class ExportIdentifier extends Identifier {
+    exported: true;
+    constructor(id: string, filePath: string, aliasId?: string, sourceFilePath?: string);
+    static isExportIdentifier(identifier: Identifier): identifier is ExportIdentifier;
+}

package/dist/extractor-options.d.ts

@@ -0,0 +1,26 @@
+import { SchemaNodeTransformer, SchemaTransformer } from './schema-transformer';
+export type ExtractorOptions = {
+    /**
+     * name of the string.
+     */
+    name?: string;
+    /**
+     * tsconfig string path.
+     */
+    tsconfig?: string;
+    /**
+     * TODO: support typescript module path.
+     */
+    /**
+     * typescript compiler options. always overrides all.
+     */
+    compilerOptions?: string;
+    /**
+     * schema transformers.
+     */
+    schemaTransformers?: SchemaTransformer[];
+    /**
+     * api transformers.
+     */
+    apiTransformers?: SchemaNodeTransformer[];
+};

package/dist/identifier-list.d.ts

@@ -0,0 +1,7 @@
+import { Identifier } from './identifier';
+export declare class IdentifierList {
+    readonly identifiers: Identifier[];
+    constructor(identifiers: Identifier[]);
+    find(identifier: Identifier): Identifier | undefined;
+    includes(identifier: Identifier): boolean;
+}

package/dist/identifier.d.ts

@@ -0,0 +1,9 @@
+export declare class Identifier {
+    readonly id: string;
+    readonly filePath: string;
+    readonly aliasId?: string | undefined;
+    readonly sourceFilePath?: string | undefined;
+    constructor(id: string, filePath: string, aliasId?: string | undefined, sourceFilePath?: string | undefined);
+    isEqual(identifier: Identifier): boolean;
+    static isDefault(identifier: Identifier): boolean;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { TypescriptConfigMutator } from '@teambit/typescript.modules.ts-config-mutator';
+export { TypeScriptExtractor } from './typescript.extractor';
+export { TypescriptCompiler } from '@teambit/typescript.typescript-compiler';
+export type { TypescriptMain, TsConfigTransformer, SchemaTransformerSlot, APITransformerSlot, } from './typescript.main.runtime';
+export type { TypeScriptCompilerOptions, TsCompilerOptionsWithoutTsConfig } from './compiler-options';
+export { TypescriptAspect } from './typescript.aspect';
+export * from './sourceFileTransformers';
+export type { SchemaNodeTransformer, SchemaTransformer } from './schema-transformer';
+export { SchemaExtractorContext } from './schema-extractor-context';

package/dist/{preview-1712805335812.js → preview-1712891953391.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@1.0.228/dist/typescript.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@1.0.228/dist/typescript.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@1.0.230/dist/typescript.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.typescript_typescript@1.0.230/dist/typescript.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/remove-types-task.d.ts

@@ -0,0 +1,8 @@
+import { BuildContext, BuildTask, BuiltTaskResult } from '@teambit/builder';
+export declare class RemoveTypesTask implements BuildTask {
+    readonly aspectId: string;
+    readonly name = "RemoveTypesProp";
+    readonly description = "remove the types prop from package.json";
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+    private removeTypesFromPkgJson;
+}

package/dist/schema-extractor-context.d.ts

@@ -0,0 +1,119 @@
+import { TsserverClient } from '@teambit/ts-server';
+import ts, { ExportAssignment, ExportDeclaration, Node, TypeNode } from 'typescript';
+import protocol from 'typescript/lib/protocol';
+import { Component } from '@teambit/component';
+import { TypeRefSchema, SchemaNode, Location, DocSchema } from '@teambit/semantics.entities.semantic-schema';
+import { ComponentDependency } from '@teambit/dependency-resolver';
+import { Formatter } from '@teambit/formatter';
+import { TypeScriptExtractor } from './typescript.extractor';
+import { IdentifierList } from './identifier-list';
+import { Identifier } from './identifier';
+export declare class SchemaExtractorContext {
+    readonly tsserver: TsserverClient;
+    readonly component: Component;
+    readonly extractor: TypeScriptExtractor;
+    readonly componentDeps: ComponentDependency[];
+    readonly componentRootPath: string;
+    readonly hostRootPath: string;
+    readonly formatter?: Formatter | undefined;
+    /**
+     * list of all declared identifiers (exported and internal) by filename
+     */
+    private _identifiers;
+    private _internalIdentifiers;
+    /**
+     * computed nodes by filename and (position (line:character))
+     */
+    private _computed;
+    get mainFile(): string;
+    get identifiers(): Map<string, IdentifierList>;
+    get internalIdentifiers(): Map<string, IdentifierList>;
+    get computed(): Map<string, SchemaNode>;
+    get mainFileIdentifierKey(): string;
+    get mainModuleIdentifiers(): IdentifierList | undefined;
+    constructor(tsserver: TsserverClient, component: Component, extractor: TypeScriptExtractor, componentDeps: ComponentDependency[], componentRootPath: string, hostRootPath: string, formatter?: Formatter | undefined);
+    getComputedNodeKey({ filePath, line, character }: Location, schema: string): string;
+    getIdentifierKeyForNode(node: Node): string;
+    getIdentifierKey(filePath: string): string;
+    setComputed(node: SchemaNode): void;
+    setIdentifiers(filePath: string, identifiers: IdentifierList): void;
+    setInternalIdentifiers(filePath: string, identifiers: IdentifierList): void;
+    findComputedSchemaByName(name: string): SchemaNode[];
+    computeSchema(node: Node): Promise<SchemaNode>;
+    transformSchemaNode(schema: SchemaNode): Promise<SchemaNode>;
+    /**
+     * returns the location of a node in a source file.
+     */
+    getLocation(node: Node, targetSourceFile?: ts.SourceFile, absolutePath?: boolean): Location;
+    getLocationAsString(node: Node): string;
+    getPathRelativeToComponent(filePath: string): string;
+    /**
+     * returns a signature for a node.
+     */
+    getSignature(node: Node): Promise<ts.server.protocol.SignatureHelpResponse | undefined>;
+    /**
+     * get the position for the tsserver.
+     */
+    getPosition(sourceFile: ts.SourceFile, line: number, offset: number): number;
+    /**
+     * get the path for a source file.
+     */
+    getPath(node: Node): string;
+    getQuickInfo(node: Node): Promise<ts.server.protocol.QuickInfoResponse | undefined>;
+    getQuickInfoDisplayString(node: Node): Promise<string>;
+    /**
+     * returns the type definition for a type.
+     */
+    typeDefinition(node: Node): Promise<ts.server.protocol.TypeDefinitionResponse | undefined>;
+    visitTypeDefinition(): void;
+    private getPathWithoutExtension;
+    private isIndexFile;
+    findFileInComponent(filePath: string): import("@teambit/legacy/dist/consumer/component/sources").AbstractVinyl | undefined;
+    private parsePackageNameFromPath;
+    /**
+     * return the file if part of the component.
+     * otherwise, a reference to the target package and the type name.
+     */
+    getSourceFileInsideComponent(filePath: string): ts.SourceFile | undefined;
+    getSourceFileFromNode(node: Node): Promise<ts.SourceFile | undefined>;
+    getFilePathByNode(node: Node): Promise<string | undefined>;
+    definitionInfo(node: Node): Promise<protocol.DefinitionInfo | undefined>;
+    /**
+     * get a definition for a given node.
+     */
+    definition(definition: protocol.DefinitionInfo): Promise<Node | undefined>;
+    /**
+     * visit a definition for node - e.g. return it's schema.
+     */
+    visitDefinition(node: Node): Promise<SchemaNode | undefined>;
+    visit(node: Node): Promise<SchemaNode>;
+    references(): void;
+    isExported(): void;
+    isFromComponent(): void;
+    getFileIdentifiers(exportDec: ExportDeclaration | ExportAssignment): Promise<Identifier[]>;
+    getFileExports(exportDec: ExportDeclaration | ExportAssignment): Promise<Identifier[]>;
+    getFileInternals(exportDec: ExportDeclaration | ExportAssignment): Promise<Identifier[]>;
+    getIdentifiers(node: Node): Promise<Identifier[]>;
+    /**
+     * tsserver has two different calls: "definition" and "typeDefinition".
+     * normally, we need the "typeDefinition" to get the type data of a node.
+     * sometimes, it has no data, for example when the node is of type TypeReference, and then using "definition" is
+     * helpful. (couldn't find a rule when to use each one. e.g. "VariableDeclaration" sometimes has data only in
+     * "definition" but it's not clear when/why).
+     */
+    getDefinition(node: Node): Promise<ts.server.protocol.FileSpanWithContext | undefined>;
+    private unknownExactType;
+    private isDefInSameLocation;
+    /**
+     * resolve a type by a node and its identifier.
+     */
+    resolveType(node: Node & {
+        type?: TypeNode;
+    }, typeStr: string, isTypeStrFromQuickInfo?: boolean): Promise<SchemaNode>;
+    private getCompIdByPkgName;
+    getTypeRef(typeStr: string, filePath: string, location: Location): Promise<TypeRefSchema | undefined>;
+    resolveTypeRef(identifier: Identifier, location: Location, isExportedFromMain?: boolean): Promise<TypeRefSchema>;
+    getTypeRefForExternalNode(node: Node): Promise<TypeRefSchema>;
+    getTypeRefForExternalPath(typeStr: string, filePath: string, location: Location): Promise<TypeRefSchema>;
+    jsDocToDocSchema(node: Node): Promise<DocSchema | undefined>;
+}

package/dist/schema-transformer.d.ts

@@ -0,0 +1,19 @@
+import { Node } from 'typescript';
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaExtractorContext } from './schema-extractor-context';
+import { Identifier } from './identifier';
+export type SchemaTransformer = {
+    /**
+     * determine whether to apply schema on given node.
+     */
+    predicate(node: Node): boolean;
+    getIdentifiers(node: Node, context: SchemaExtractorContext): Promise<Identifier[]>;
+    /**
+     * transform the node into JSONSchema.
+     */
+    transform(node: Node, context: SchemaExtractorContext): Promise<SchemaNode>;
+};
+export type SchemaNodeTransformer = {
+    predicate(node: SchemaNode): boolean;
+    transform(node: SchemaNode, context: SchemaExtractorContext): Promise<SchemaNode | null>;
+};

package/dist/schema-transformer.plugin.d.ts

@@ -0,0 +1,9 @@
+import { PluginDefinition } from '@teambit/aspect-loader';
+import { SchemaTransformerSlot } from './typescript.main.runtime';
+export declare class SchemaTransformerPlugin implements PluginDefinition {
+    private schemaTransformerSlot;
+    constructor(schemaTransformerSlot: SchemaTransformerSlot);
+    pattern: string;
+    runtimes: string[];
+    register(object: any): void;
+}

package/dist/sourceFileTransformers/class.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function classNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile>;

package/dist/sourceFileTransformers/empty-line-encoder.d.ts

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+export declare class EmptyLineEncoder {
+    static readonly defaultEmptyLineMarker: string;
+    static readonly defaultNewLine: string;
+    constructor(emptyLineMarker?: string, newLine?: string);
+    emptyLineMarker: string;
+    newLine: string;
+    encode(text: string): string;
+    decode(text: string): string;
+    addLeadingEmptyLineMarker<T extends ts.Node>(node: T): T;
+}
+export declare function encodeEmptyLines(text: string, emptyLineMarker?: string, newLine?: string): string;
+export declare function decodeEmptyLines(text: string, emptyLineMarker?: string, newLine?: string): string;
+export declare function addLeadingEmptyLineMarker<T extends ts.Node>(node: T, emptyLineMarker?: string): T;

package/dist/sourceFileTransformers/export.d.ts

@@ -0,0 +1,2 @@
+import { SourceFileTransformer } from '.';
+export declare const exportTransformer: SourceFileTransformer;

package/dist/sourceFileTransformers/expression-statement.d.ts

@@ -0,0 +1,2 @@
+import { SourceFileTransformer } from '.';
+export declare const expressionStatementTransformer: SourceFileTransformer;

package/dist/sourceFileTransformers/function.d.ts

@@ -0,0 +1,2 @@
+import { SourceFileTransformer } from '.';
+export declare const functionNamesTransformer: SourceFileTransformer;

package/dist/sourceFileTransformers/import.d.ts

@@ -0,0 +1,2 @@
+import { SourceFileTransformer } from '.';
+export declare const importTransformer: SourceFileTransformer;

package/dist/sourceFileTransformers/index.d.ts

@@ -0,0 +1,12 @@
+import ts from 'typescript';
+export type SourceFileTransformer = (mapping: Record<string, string>) => ts.TransformerFactory<ts.SourceFile>;
+export { classNamesTransformer } from './class';
+export { interfaceNamesTransformer } from './interface';
+export { variableNamesTransformer } from './variable';
+export { functionNamesTransformer } from './function';
+export { typeAliasNamesTransformer } from './typeAlias';
+export { importTransformer } from './import';
+export { expressionStatementTransformer } from './expression-statement';
+export { exportTransformer } from './export';
+export { transformSourceFile } from './transform';
+export { typeReferenceTransformer } from './type-reference';

package/dist/sourceFileTransformers/interface.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function interfaceNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile>;

package/dist/sourceFileTransformers/replaceName.d.ts

@@ -0,0 +1 @@
+export declare function replaceName(oldName: string, nameMapping: Record<string, string>): string | undefined;

package/dist/sourceFileTransformers/transform.d.ts

@@ -0,0 +1,12 @@
+import { Formatter } from '@teambit/formatter';
+import ts from 'typescript';
+/**
+ * Transforms a TypeScript source file using the provided transformer.
+ *
+ * @param sourceFilePath Path to the TypeScript source file.
+ * @param sourceFileContent The content of the source file.
+ * @param transformers The transformers to be applied on the source file.
+ * @param formatter (Optional) An optional formatter to format the transformed code. If no formatter is provided, the function returns the transformed source file as a string without any formatting.
+ * @returns A promise that resolves to the transformed source file as a string.
+ */
+export declare function transformSourceFile(sourceFilePath: string, sourceFileContent: string, transformers: ts.TransformerFactory<ts.SourceFile>[], formatter?: Formatter, updates?: Record<string, string>): Promise<string>;

package/dist/sourceFileTransformers/type-reference.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function typeReferenceTransformer(mapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile>;

package/dist/sourceFileTransformers/typeAlias.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function typeAliasNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile>;

package/dist/sourceFileTransformers/variable.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function variableNamesTransformer(nameMapping: Record<string, string>): ts.TransformerFactory<ts.SourceFile>;

package/dist/transform-source-file.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transformers/array-literal-expression.d.ts

@@ -0,0 +1,10 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { ArrayLiteralExpression, Node } from 'typescript';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { Identifier } from '../identifier';
+export declare class ArrayLiteralExpressionTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: ArrayLiteralExpression, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/array-type.d.ts

@@ -0,0 +1,10 @@
+import { ArrayTypeNode, Node } from 'typescript';
+import { TypeArraySchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ArrayTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: ArrayTypeNode, context: SchemaExtractorContext): Promise<TypeArraySchema>;
+}

package/dist/transformers/binding-element.d.ts

@@ -0,0 +1,17 @@
+import { BindingElement, Node } from 'typescript';
+import { VariableLikeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+/**
+ * for example:
+ *
+ * const objBindingElem = { elem1: 1, elem2: 2 };
+ * const { elem1 } = objBindingElem;
+ * export { elem1 };
+ */
+export declare class BindingElementTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(node: BindingElement): Promise<Identifier[]>;
+    transform(node: BindingElement, context: SchemaExtractorContext): Promise<VariableLikeSchema>;
+}

package/dist/transformers/class-declaration.d.ts

@@ -0,0 +1,12 @@
+import { ClassSchema } from '@teambit/semantics.entities.semantic-schema';
+import { Node, ClassDeclaration } from 'typescript';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ClassDeclarationTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    private getName;
+    getIdentifiers(node: ClassDeclaration): Promise<Identifier[]>;
+    private getExpressionWithTypeArgs;
+    transform(node: ClassDeclaration, context: SchemaExtractorContext): Promise<ClassSchema>;
+}

package/dist/transformers/conditional-type.d.ts

@@ -0,0 +1,10 @@
+import { Node, ConditionalTypeNode } from 'typescript';
+import { ConditionalTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ConditionalTypeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: ConditionalTypeNode, context: SchemaExtractorContext): Promise<ConditionalTypeSchema>;
+}

package/dist/transformers/constructor.d.ts

@@ -0,0 +1,10 @@
+import { Node, ConstructorDeclaration } from 'typescript';
+import { ConstructorSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ConstructorTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: ConstructorDeclaration, context: SchemaExtractorContext): Promise<ConstructorSchema>;
+}

package/dist/transformers/decorator.d.ts

@@ -0,0 +1,10 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { Decorator, Node } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { Identifier } from '../identifier';
+export declare class DecoratorTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(decorator: Decorator): Promise<Identifier[]>;
+    transform(node: Decorator, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/enum-declaration.d.ts

@@ -0,0 +1,10 @@
+import { Node, EnumDeclaration } from 'typescript';
+import { EnumSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class EnumDeclarationTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(node: EnumDeclaration): Promise<Identifier[]>;
+    transform(enumDec: EnumDeclaration, context: SchemaExtractorContext): Promise<EnumSchema>;
+}

package/dist/transformers/export-assignment.d.ts

@@ -0,0 +1,14 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { Node, ExportAssignment as ExportAssignmentNode } from 'typescript';
+import { ExportIdentifier } from '../export-identifier';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+/**
+ * This is either an export = or an export default declaration.
+ * Unless isExportEquals is set, this node was parsed as an export default
+ */
+export declare class ExportAssignmentTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(exportDec: ExportAssignmentNode): Promise<ExportIdentifier[]>;
+    transform(exportDec: ExportAssignmentNode, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/export-declaration.d.ts

@@ -0,0 +1,9 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { Node, ExportDeclaration as ExportDeclarationNode } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+export declare class ExportDeclarationTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(exportDec: ExportDeclarationNode, context: SchemaExtractorContext): Promise<import("../identifier").Identifier[]>;
+    transform(exportDec: ExportDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/expression-statement.d.ts

@@ -0,0 +1,10 @@
+import { Node, ExpressionStatement } from 'typescript';
+import { UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ExpressionStatementTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: ExpressionStatement, context: SchemaExtractorContext): Promise<UnImplementedSchema>;
+}

package/dist/transformers/function-like.d.ts

@@ -0,0 +1,11 @@
+import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { Node, SignatureDeclaration } from 'typescript';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { SchemaTransformer } from '../schema-transformer';
+import { Identifier } from '../identifier';
+export declare class FunctionLikeTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(funcDec: SignatureDeclaration): Promise<Identifier[]>;
+    private getName;
+    transform(node: SignatureDeclaration, context: SchemaExtractorContext): Promise<SchemaNode>;
+}

package/dist/transformers/get-accessor.d.ts

@@ -0,0 +1,10 @@
+import { Node, GetAccessorDeclaration } from 'typescript';
+import { GetAccessorSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class GetAccessorTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: GetAccessorDeclaration, context: SchemaExtractorContext): Promise<GetAccessorSchema>;
+}

package/dist/transformers/import-declaration.d.ts

@@ -0,0 +1,10 @@
+import { ImportDeclaration, Node } from 'typescript';
+import { UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class ImportDeclarationTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(importDec: ImportDeclaration): Promise<Identifier[]>;
+    transform(node: ImportDeclaration, context: SchemaExtractorContext): Promise<UnImplementedSchema>;
+}

package/dist/transformers/index-signature.d.ts

@@ -0,0 +1,10 @@
+import { Node, IndexSignatureDeclaration } from 'typescript';
+import { IndexSignatureSchema, UnresolvedSchema } from '@teambit/semantics.entities.semantic-schema';
+import { SchemaTransformer } from '../schema-transformer';
+import { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+export declare class IndexSignatureTransformer implements SchemaTransformer {
+    predicate(node: Node): boolean;
+    getIdentifiers(): Promise<Identifier[]>;
+    transform(node: IndexSignatureDeclaration, context: SchemaExtractorContext): Promise<IndexSignatureSchema | UnresolvedSchema>;
+}