@teambit/typescript 1.0.226 → 1.0.227

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

@@ -1,10 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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>;
-}

package/dist/transformers/index.d.ts

@@ -1,43 +0,0 @@
-export { ExportDeclarationTransformer } from './export-declaration';
-export { FunctionLikeTransformer } from './function-like';
-export { ParameterTransformer } from './parameter';
-export { VariableStatementTransformer } from './variable-statement';
-export { VariableDeclaration } from './variable-declaration';
-export { SourceFileTransformer } from './source-file-transformer';
-export { TypeAliasTransformer } from './type-alias';
-export { IntersectionTypeTransformer } from './intersection-type';
-export { UnionTypeTransformer } from './union-type';
-export { TypeReferenceTransformer } from './type-reference';
-export { TypeLiteralTransformer } from './type-literal';
-export { LiteralTypeTransformer } from './literal-type';
-export { TypeQueryTransformer } from './type-query';
-export { TypeOperatorTransformer } from './type-operator';
-export { KeywordTypeTransformer } from './keyword-type';
-export { TupleTypeTransformer } from './tuple-type';
-export { ParenthesizedTypeTransformer } from './parenthesized-type';
-export { TypePredicateTransformer } from './type-predicate';
-export { IndexedAccessTypeTransformer } from './indexed-access-type';
-export { TemplateLiteralTypeSpanTransformer } from './template-literal-type-span';
-export { TemplateLiteralTypeTransformer } from './template-literal-type';
-export { ThisTypeTransformer } from './this-type';
-export { ConditionalTypeTransformer } from './conditional-type';
-export { NamedTupleTransformer } from './named-tuple';
-export { ArrayTypeTransformer } from './array-type';
-export { ClassDeclarationTransformer } from './class-declaration';
-export { ConstructorTransformer } from './constructor';
-export { PropertyDeclarationTransformer } from './property-declaration';
-export { SetAccessorTransformer } from './set-accessor';
-export { GetAccessorTransformer } from './get-accessor';
-export { IndexSignatureTransformer } from './index-signature';
-export { InterfaceDeclarationTransformer } from './interface-declaration';
-export { EnumDeclarationTransformer } from './enum-declaration';
-export { BindingElementTransformer } from './binding-element';
-export { ExportAssignmentTransformer } from './export-assignment';
-export { ImportDeclarationTransformer } from './import-declaration';
-export { ExpressionStatementTransformer } from './expression-statement';
-export { ModuleDeclarationTransformer } from './module-declaration';
-export { DecoratorTransformer } from './decorator';
-export { ArrayLiteralExpressionTransformer } from './array-literal-expression';
-export { ObjectLiteralExpressionTransformer } from './object-literal-expression';
-export { PropertyAssignmentTransformer } from './property-assignment';
-export { LiteralValueTransformer } from './literal-value';

package/dist/transformers/indexed-access-type.d.ts

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

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

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

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

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

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

@@ -1,13 +0,0 @@
-import { Node } from 'typescript';
-import { KeywordTypeSchema } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-/**
- * whether it's kind of `ts.KeywordTypeSyntaxKind`
- */
-export declare class KeywordTypeTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: Node, context: SchemaExtractorContext): Promise<KeywordTypeSchema>;
-}

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

@@ -1,13 +0,0 @@
-import { LiteralTypeNode, Node } from 'typescript';
-import { LiteralTypeSchema } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-/**
- * e.g. string/boolean
- */
-export declare class LiteralTypeTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: LiteralTypeNode, context: SchemaExtractorContext): Promise<LiteralTypeSchema>;
-}

package/dist/transformers/literal-value.d.ts

@@ -1,11 +0,0 @@
-import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import ts, { Node, StringLiteral } from 'typescript';
-import type { SchemaExtractorContext } from '../schema-extractor-context';
-import { SchemaTransformer } from '../schema-transformer';
-import { Identifier } from '../identifier';
-export type LiteralValueNode = StringLiteral | ts.NumericLiteral | ts.TrueLiteral | ts.FalseLiteral | ts.NullLiteral | ts.BigIntLiteral | ts.RegularExpressionLiteral | ts.NewExpression;
-export declare class LiteralValueTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: LiteralValueNode, context: SchemaExtractorContext): Promise<SchemaNode>;
-}

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

@@ -1,10 +0,0 @@
-import { Node, ModuleDeclaration } 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 ModuleDeclarationTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: ModuleDeclaration, context: SchemaExtractorContext): Promise<UnImplementedSchema>;
-}

package/dist/transformers/named-tuple.d.ts

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

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

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

package/dist/transformers/parameter.d.ts

@@ -1,13 +0,0 @@
-import { Node, ParameterDeclaration } from 'typescript';
-import { ParameterSchema, SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-export declare class ParameterTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: ParameterDeclaration, context: SchemaExtractorContext): Promise<ParameterSchema<SchemaNode>>;
-    static getName(param: ParameterDeclaration): string;
-    getType(param: ParameterDeclaration, context: SchemaExtractorContext): Promise<SchemaNode>;
-    static getObjectBindingNodes(param: ParameterDeclaration, paramType: SchemaNode, context: SchemaExtractorContext): Promise<SchemaNode[] | undefined>;
-}

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

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

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

@@ -1,9 +0,0 @@
-import { Node, PropertyAssignment } from 'typescript';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { SchemaTransformer } from '../schema-transformer';
-import { Identifier } from '../identifier';
-export declare class PropertyAssignmentTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: PropertyAssignment, context: SchemaExtractorContext): Promise<any>;
-}

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

@@ -1,11 +0,0 @@
-import { Node, PropertyDeclaration, PropertySignature } 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';
-export declare class PropertyDeclarationTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    private isComputedProperty;
-    transform(node: PropertyDeclaration | PropertySignature, context: SchemaExtractorContext): Promise<VariableLikeSchema>;
-}

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

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

package/dist/transformers/source-file-transformer.d.ts

@@ -1,15 +0,0 @@
-import { Node, SourceFile } from 'typescript';
-import { ModuleSchema } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-export declare class SourceFileTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(sourceFile: SourceFile, context: SchemaExtractorContext): Promise<Identifier[]>;
-    transform(node: SourceFile, context: SchemaExtractorContext): Promise<ModuleSchema>;
-    /**
-     * list all exports of a source file.
-     */
-    private listExports;
-    private listInternalNodes;
-}

package/dist/transformers/template-literal-type-span.d.ts

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

package/dist/transformers/template-literal-type.d.ts

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

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

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

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

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

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

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

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

@@ -1,14 +0,0 @@
-import { Node, TypeLiteralNode } from 'typescript';
-import { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-/**
- * not to be confused with "LiteralType", which is string/boolean/null.
- * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
- */
-export declare class TypeLiteralTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: TypeLiteralNode, context: SchemaExtractorContext): Promise<TypeLiteralSchema>;
-}

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

@@ -1,14 +0,0 @@
-import { Node, TypeOperatorNode, SyntaxKind } from 'typescript';
-import { TypeOperatorSchema } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-/**
- * e.g. keyof typeof Foo
- */
-export declare class TypeOperatorTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: TypeOperatorNode, context: SchemaExtractorContext): Promise<TypeOperatorSchema>;
-    getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword): "readonly" | "keyof" | "unique";
-}

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

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

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

@@ -1,13 +0,0 @@
-import { Node, TypeQueryNode } from 'typescript';
-import { TypeQuerySchema } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-/**
- * e.g. `typeof Foo`
- */
-export declare class TypeQueryTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: TypeQueryNode, context: SchemaExtractorContext): Promise<TypeQuerySchema>;
-}

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

@@ -1,17 +0,0 @@
-import { Node, TypeReferenceNode } from 'typescript';
-import { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-/**
- * In the following example, `AriaButtonProps` is a type reference
- * ```ts
- * import type { AriaButtonProps } from '@react-types/button';
- * export type ButtonProps = AriaButtonProps & { a: string };
- * ```
- */
-export declare class TypeReferenceTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(): Promise<Identifier[]>;
-    transform(node: TypeReferenceNode, context: SchemaExtractorContext): Promise<import("@teambit/semantics.entities.semantic-schema").SchemaNode | TypeRefSchema>;
-}

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

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

package/dist/transformers/utils/jsdoc-to-doc-schema.d.ts

@@ -1,5 +0,0 @@
-import { JSDocTag } from 'typescript';
-import { TagSchema } from '@teambit/semantics.entities.semantic-schema';
-import { Formatter } from '@teambit/formatter';
-import { SchemaExtractorContext } from '../../schema-extractor-context';
-export declare function tagParser(tag: JSDocTag, context: SchemaExtractorContext, formatter?: Formatter): Promise<TagSchema>;

package/dist/transformers/utils/parse-type-from-quick-info.d.ts

@@ -1,36 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-export declare const UNRESOLVED = "<<unresolved>>";
-/**
- * try to parse the type from the quickinfo.
- * this is an error-prone process, we do our best here.
- *
- * an example of a function with many ":"
- * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`
- * which produce the following quickinfo:
- * ```ts
- * function getObj(a: string, func: (b: number) => {}): {
- *   a: number;
- *   b: number;
- * }
- * ```
- *
- * some examples of quickinfo:
- *
- * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]
- *
- * const enum ts.TypeFormatFlags
- *
- * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string
- *
- * const obj: {
- *   a: number;
- *   b: number;
- *  }
- *
- * function getObj(a: string): {
- *     a: number;
- *     b: number;
- * }
- */
-export declare function parseTypeFromQuickInfo(quickInfo: ts.server.protocol.QuickInfoResponse | undefined): string;
-export declare function parseReturnTypeFromQuickInfo(quickInfo: ts.server.protocol.QuickInfoResponse | undefined): string;

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

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

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

@@ -1,14 +0,0 @@
-import { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
-import { Node, VariableStatement } from 'typescript';
-import { SchemaTransformer } from '../schema-transformer';
-import { SchemaExtractorContext } from '../schema-extractor-context';
-import { Identifier } from '../identifier';
-/**
- * variable statement is a collection of variable declarations.
- * e.g. `export const a = 1, b = () => {}, c = {};`
- */
-export declare class VariableStatementTransformer implements SchemaTransformer {
-    predicate(node: Node): boolean;
-    getIdentifiers(node: VariableStatement): Promise<Identifier[]>;
-    transform(node: VariableStatement, context: SchemaExtractorContext): Promise<SchemaNode>;
-}

package/dist/tsconfig-writer.d.ts

@@ -1,49 +0,0 @@
-import { ExecutionContext } from '@teambit/envs';
-import { Workspace } from '@teambit/workspace';
-import { Logger } from '@teambit/logger';
-import { TsconfigWriterOptions } from './typescript.main.runtime';
-export type TsconfigPathsPerEnv = {
-    envIds: string[];
-    tsconfig: string;
-    paths: string[];
-};
-export declare class TsconfigWriter {
-    private workspace;
-    private logger;
-    constructor(workspace: Workspace, logger: Logger);
-    write(envsExecutionContext: ExecutionContext[], options: TsconfigWriterOptions): Promise<TsconfigPathsPerEnv[]>;
-    private getTsconfigFromEnv;
-    clean(envsExecutionContext: ExecutionContext[], { dryRun, silent }: TsconfigWriterOptions): Promise<string[]>;
-    private promptForWriting;
-    private promptForCleaning;
-    private deleteFiles;
-    private writeFiles;
-    private getPathsPerEnv;
-}
-type PathsPerEnvIds = {
-    ids: string[];
-    paths: string[];
-};
-/**
- * easier to understand by an example:
- * input:
- * [
- *   { id: react, paths: [ui/button, ui/form] },
- *   { id: aspect, paths: [p/a1, p/a2] },
- *   { id: node, paths: [p/n1] },
- * ]
- *
- * output:
- * [
- *   { id: react, paths: [ui] },
- *   { id: aspect, paths: [p] },
- *   { id: node, paths: [p/n1] },
- * ]
- *
- * the goal is to minimize the amount of files to write per env if possible.
- * when multiple components of the same env share a root-dir, then, it's enough to write a file in that shared dir.
- * if in a shared-dir, some components using env1 and some env2, it finds the env that has the max number of
- * components, this env will be optimized. other components, will have the files written inside their dirs.
- */
-export declare function dedupePaths(pathsPerEnvId: PathsPerEnvIds[]): PathsPerEnvIds[];
-export {};

package/dist/typescript.aspect.d.ts

@@ -1,2 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-export declare const TypescriptAspect: Aspect;

package/dist/typescript.composition.d.ts

@@ -1 +0,0 @@
-export declare const Logo: () => import("react/jsx-runtime").JSX.Element;