ts-json-schema-generator

  • Version 2.3.0
  • Published
  • 844 kB
  • 8 dependencies
  • MIT license

Install

npm i ts-json-schema-generator
yarn add ts-json-schema-generator
pnpm add ts-json-schema-generator

Overview

Generate JSON schema from your Typescript sources

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable DEFAULT_CONFIG

const DEFAULT_CONFIG: Omit<
Required<Config>,
'path' | 'type' | 'schemaId' | 'tsconfig'
>;

    variable intrinsicMethods

    const intrinsicMethods: Record<string, (v: string) => string>;

      Functions

      function createFormatter

      createFormatter: (
      config: CompletedConfig,
      augmentor?: FormatterAugmentor
      ) => TypeFormatter;

        function createGenerator

        createGenerator: (config: Config) => SchemaGenerator;

          function createParser

          createParser: (
          program: ts.Program,
          config: CompletedConfig,
          augmentor?: ParserAugmentor
          ) => NodeParser;

            function createProgram

            createProgram: (config: CompletedConfig) => ts.Program;

              function deepMerge

              deepMerge: (
              a: { [key: string]: JSONSchema7Definition },
              b: { [key: string]: JSONSchema7Definition }
              ) => { [x: string]: JSONSchema7Definition };

                function derefAliasedType

                derefAliasedType: (type: BaseType) => BaseType;

                  function derefAnnotatedType

                  derefAnnotatedType: (type: BaseType) => BaseType;

                    function derefType

                    derefType: (type: BaseType) => BaseType;

                      function extractLiterals

                      extractLiterals: (type: BaseType) => string[];

                        function getAllOfDefinitionReducer

                        getAllOfDefinitionReducer: (
                        childTypeFormatter: TypeFormatter
                        ) => (definition: JSONSchema7, baseType: BaseType) => JSONSchema7;

                          function getKey

                          getKey: (node: Node, context: Context) => string;

                            function getNamedArguments

                            getNamedArguments: (
                            childNodeParser: NodeParser,
                            node:
                            | ts.FunctionTypeNode
                            | ts.FunctionExpression
                            | ts.FunctionDeclaration
                            | ts.ArrowFunction
                            | ts.ConstructorTypeNode,
                            context: Context
                            ) => ObjectType | undefined;

                              function getTypeByKey

                              getTypeByKey: (
                              type: BaseType,
                              index: LiteralType | StringType | NumberType
                              ) => BaseType | undefined;

                                function getTypeKeys

                                getTypeKeys: (type: BaseType) => LiteralType[];

                                  function getTypeName

                                  getTypeName: (
                                  node:
                                  | ts.FunctionTypeNode
                                  | ts.FunctionExpression
                                  | ts.FunctionDeclaration
                                  | ts.ArrowFunction
                                  | ts.ConstructorTypeNode
                                  ) => string | undefined;

                                    function hash

                                    hash: (
                                    a: string | boolean | number | (string | boolean | number)[] | object
                                    ) => string | number;

                                      function hasJsDocTag

                                      hasJsDocTag: (node: ts.Node, tagName: string) => boolean;

                                        function hasModifier

                                        hasModifier: (node: ts.HasModifiers, modifier: ts.SyntaxKind) => boolean;

                                          function intersectionOfArrays

                                          intersectionOfArrays: <T>(a: T[], b: T[]) => T[];

                                            function isAssignableTo

                                            isAssignableTo: (
                                            target: BaseType,
                                            source: BaseType,
                                            inferMap?: Map<string, BaseType>,
                                            insideTypes?: Set<BaseType>
                                            ) => boolean;

                                              function isHiddenType

                                              isHiddenType: (type: BaseType) => boolean;

                                                function isLiteralUnion

                                                isLiteralUnion: (type: UnionType) => boolean;

                                                  function isNodeHidden

                                                  isNodeHidden: (node: ts.Node) => boolean;

                                                    function isPublic

                                                    isPublic: (node: ts.HasModifiers) => boolean;

                                                      function isStatic

                                                      isStatic: (node: ts.HasModifiers) => boolean;

                                                        function makeNullable

                                                        makeNullable: (def: JSONSchema7) => JSONSchema7;

                                                          function narrowType

                                                          narrowType: (type: BaseType, predicate: (type: BaseType) => boolean) => BaseType;

                                                            function notNever

                                                            notNever: (x: BaseType) => boolean;

                                                              function preserveAnnotation

                                                              preserveAnnotation: (originalType: BaseType, newType: BaseType) => BaseType;

                                                                function removeUndefined

                                                                removeUndefined: (propertyType: UnionType) => {
                                                                numRemoved: number;
                                                                newType: BaseType;
                                                                };

                                                                  function removeUnreachable

                                                                  removeUnreachable: (
                                                                  rootTypeDefinition: Definition | undefined,
                                                                  definitions: StringMap<Definition>
                                                                  ) => StringMap<Definition>;

                                                                    function strip

                                                                    strip: (input: string, chars?: Set<string>) => string;

                                                                      function symbolAtNode

                                                                      symbolAtNode: (node: ts.Node) => ts.Symbol | undefined;

                                                                        function translate

                                                                        translate: (types: BaseType[]) => BaseType;

                                                                          function typeName

                                                                          typeName: (value: JSONSchema7Type) => JSONSchema7TypeName;

                                                                            function uniqueArray

                                                                            uniqueArray: <T>(array: readonly T[]) => T[];

                                                                              function uniqueTypeArray

                                                                              uniqueTypeArray: <T extends BaseType>(types: T[]) => T[];

                                                                                Classes

                                                                                class AliasType

                                                                                class AliasType extends BaseType {}

                                                                                  constructor

                                                                                  constructor(id: string, type: BaseType);

                                                                                    method getId

                                                                                    getId: () => string;

                                                                                      method getType

                                                                                      getType: () => BaseType;

                                                                                        class AliasTypeFormatter

                                                                                        class AliasTypeFormatter implements SubTypeFormatter {}

                                                                                          constructor

                                                                                          constructor(childTypeFormatter: TypeFormatter);

                                                                                            property childTypeFormatter

                                                                                            protected childTypeFormatter: TypeFormatter;

                                                                                              method getChildren

                                                                                              getChildren: (type: AliasType) => BaseType[];

                                                                                                method getDefinition

                                                                                                getDefinition: (type: AliasType) => JSONSchema7;

                                                                                                  method supportsType

                                                                                                  supportsType: (type: BaseType) => boolean;

                                                                                                    class AnnotatedNodeParser

                                                                                                    class AnnotatedNodeParser implements SubNodeParser {}

                                                                                                      constructor

                                                                                                      constructor(
                                                                                                      childNodeParser: SubNodeParser,
                                                                                                      annotationsReader: AnnotationsReader
                                                                                                      );

                                                                                                        property annotationsReader

                                                                                                        protected annotationsReader: AnnotationsReader;

                                                                                                          property childNodeParser

                                                                                                          protected childNodeParser: SubNodeParser;

                                                                                                            method createType

                                                                                                            createType: (
                                                                                                            node: ts.Node,
                                                                                                            context: Context,
                                                                                                            reference?: ReferenceType
                                                                                                            ) => BaseType;

                                                                                                              method getAnnotatedNode

                                                                                                              protected getAnnotatedNode: (node: ts.Node) => ts.Node;

                                                                                                                method getNullable

                                                                                                                protected getNullable: (annotatedNode: ts.Node) => boolean;

                                                                                                                  method supportsNode

                                                                                                                  supportsNode: (node: ts.Node) => boolean;

                                                                                                                    class AnnotatedType

                                                                                                                    class AnnotatedType extends BaseType {}

                                                                                                                      constructor

                                                                                                                      constructor(type: BaseType, annotations: Annotations, nullable: boolean);

                                                                                                                        method getAnnotations

                                                                                                                        getAnnotations: () => Annotations;

                                                                                                                          method getId

                                                                                                                          getId: () => string;

                                                                                                                            method getType

                                                                                                                            getType: () => BaseType;

                                                                                                                              method isNullable

                                                                                                                              isNullable: () => boolean;

                                                                                                                                class AnnotatedTypeFormatter

                                                                                                                                class AnnotatedTypeFormatter implements SubTypeFormatter {}

                                                                                                                                  constructor

                                                                                                                                  constructor(childTypeFormatter: TypeFormatter);

                                                                                                                                    property childTypeFormatter

                                                                                                                                    protected childTypeFormatter: TypeFormatter;

                                                                                                                                      method getChildren

                                                                                                                                      getChildren: (type: AnnotatedType) => BaseType[];

                                                                                                                                        method getDefinition

                                                                                                                                        getDefinition: (type: AnnotatedType) => JSONSchema7;

                                                                                                                                          method supportsType

                                                                                                                                          supportsType: (type: BaseType) => boolean;

                                                                                                                                            class AnyType

                                                                                                                                            class AnyType extends BaseType {}

                                                                                                                                              method getId

                                                                                                                                              getId: () => string;

                                                                                                                                                class AnyTypeFormatter

                                                                                                                                                class AnyTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                  method getChildren

                                                                                                                                                  getChildren: (type: AnyType) => BaseType[];

                                                                                                                                                    method getDefinition

                                                                                                                                                    getDefinition: (type: AnyType) => JSONSchema7;

                                                                                                                                                      method supportsType

                                                                                                                                                      supportsType: (type: BaseType) => boolean;

                                                                                                                                                        class AnyTypeNodeParser

                                                                                                                                                        class AnyTypeNodeParser implements SubNodeParser {}

                                                                                                                                                          method createType

                                                                                                                                                          createType: (node: ts.KeywordTypeNode, context: Context) => BaseType;

                                                                                                                                                            method supportsNode

                                                                                                                                                            supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                              class ArrayLiteralExpressionNodeParser

                                                                                                                                                              class ArrayLiteralExpressionNodeParser implements SubNodeParser {}

                                                                                                                                                                constructor

                                                                                                                                                                constructor(childNodeParser: NodeParser);

                                                                                                                                                                  property childNodeParser

                                                                                                                                                                  protected childNodeParser: NodeParser;

                                                                                                                                                                    method createType

                                                                                                                                                                    createType: (node: ts.ArrayLiteralExpression, context: Context) => BaseType;

                                                                                                                                                                      method supportsNode

                                                                                                                                                                      supportsNode: (node: ts.ArrayLiteralExpression) => boolean;

                                                                                                                                                                        class ArrayNodeParser

                                                                                                                                                                        class ArrayNodeParser implements SubNodeParser {}

                                                                                                                                                                          constructor

                                                                                                                                                                          constructor(childNodeParser: NodeParser);

                                                                                                                                                                            property childNodeParser

                                                                                                                                                                            protected childNodeParser: NodeParser;

                                                                                                                                                                              method createType

                                                                                                                                                                              createType: (node: ts.ArrayTypeNode, context: Context) => BaseType;

                                                                                                                                                                                method supportsNode

                                                                                                                                                                                supportsNode: (node: ts.ArrayTypeNode) => boolean;

                                                                                                                                                                                  class ArrayType

                                                                                                                                                                                  class ArrayType extends BaseType {}

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(item: BaseType);

                                                                                                                                                                                      method getId

                                                                                                                                                                                      getId: () => string;

                                                                                                                                                                                        method getItem

                                                                                                                                                                                        getItem: () => BaseType;

                                                                                                                                                                                          class ArrayTypeFormatter

                                                                                                                                                                                          class ArrayTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(childTypeFormatter: TypeFormatter);

                                                                                                                                                                                              method getChildren

                                                                                                                                                                                              getChildren: (type: ArrayType) => BaseType[];

                                                                                                                                                                                                method getDefinition

                                                                                                                                                                                                getDefinition: (type: ArrayType) => JSONSchema7;

                                                                                                                                                                                                  method supportsType

                                                                                                                                                                                                  supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                    class AsExpressionNodeParser

                                                                                                                                                                                                    class AsExpressionNodeParser implements SubNodeParser {}

                                                                                                                                                                                                      constructor

                                                                                                                                                                                                      constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                        property childNodeParser

                                                                                                                                                                                                        protected childNodeParser: NodeParser;

                                                                                                                                                                                                          method createType

                                                                                                                                                                                                          createType: (node: ts.AsExpression, context: Context) => BaseType;

                                                                                                                                                                                                            method supportsNode

                                                                                                                                                                                                            supportsNode: (node: ts.AsExpression) => boolean;

                                                                                                                                                                                                              class BaseError

                                                                                                                                                                                                              abstract class BaseError extends Error {}

                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                constructor(diagnostic: PartialDiagnostic);

                                                                                                                                                                                                                  property diagnostic

                                                                                                                                                                                                                  readonly diagnostic: ts.Diagnostic;

                                                                                                                                                                                                                    method createDiagnostic

                                                                                                                                                                                                                    static createDiagnostic: (diagnostic: PartialDiagnostic) => ts.Diagnostic;

                                                                                                                                                                                                                      method format

                                                                                                                                                                                                                      format: () => string;

                                                                                                                                                                                                                        class BaseType

                                                                                                                                                                                                                        abstract class BaseType {}

                                                                                                                                                                                                                          method getId

                                                                                                                                                                                                                          abstract getId: () => string;

                                                                                                                                                                                                                            method getName

                                                                                                                                                                                                                            getName: () => string;

                                                                                                                                                                                                                              class BasicAnnotationsReader

                                                                                                                                                                                                                              class BasicAnnotationsReader implements AnnotationsReader {}

                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                constructor(extraTags?: Set<string>);

                                                                                                                                                                                                                                  method getAnnotations

                                                                                                                                                                                                                                  getAnnotations: (node: ts.Node) => Annotations | undefined;

                                                                                                                                                                                                                                    class BooleanLiteralNodeParser

                                                                                                                                                                                                                                    class BooleanLiteralNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                      method createType

                                                                                                                                                                                                                                      createType: (node: ts.BooleanLiteral, context: Context) => BaseType;

                                                                                                                                                                                                                                        method supportsNode

                                                                                                                                                                                                                                        supportsNode: (node: ts.BooleanLiteral) => boolean;

                                                                                                                                                                                                                                          class BooleanType

                                                                                                                                                                                                                                          class BooleanType extends PrimitiveType {}

                                                                                                                                                                                                                                            method getId

                                                                                                                                                                                                                                            getId: () => string;

                                                                                                                                                                                                                                              class BooleanTypeFormatter

                                                                                                                                                                                                                                              class BooleanTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                method getChildren

                                                                                                                                                                                                                                                getChildren: (type: BooleanType) => BaseType[];

                                                                                                                                                                                                                                                  method getDefinition

                                                                                                                                                                                                                                                  getDefinition: (type: BooleanType) => JSONSchema7;

                                                                                                                                                                                                                                                    method supportsType

                                                                                                                                                                                                                                                    supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                      class BooleanTypeNodeParser

                                                                                                                                                                                                                                                      class BooleanTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                        method createType

                                                                                                                                                                                                                                                        createType: (node: ts.KeywordTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                          method supportsNode

                                                                                                                                                                                                                                                          supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                            class BuildError

                                                                                                                                                                                                                                                            class BuildError extends BaseError {}

                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                              constructor(diag: Omit<PartialDiagnostic, 'code'>);

                                                                                                                                                                                                                                                                class CallExpressionParser

                                                                                                                                                                                                                                                                class CallExpressionParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                  constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                    property childNodeParser

                                                                                                                                                                                                                                                                    protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                      property typeChecker

                                                                                                                                                                                                                                                                      protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                        method createSubContext

                                                                                                                                                                                                                                                                        protected createSubContext: (
                                                                                                                                                                                                                                                                        node: ts.CallExpression,
                                                                                                                                                                                                                                                                        parentContext: Context
                                                                                                                                                                                                                                                                        ) => Context;

                                                                                                                                                                                                                                                                          method createType

                                                                                                                                                                                                                                                                          createType: (node: ts.CallExpression, context: Context) => BaseType;

                                                                                                                                                                                                                                                                            method supportsNode

                                                                                                                                                                                                                                                                            supportsNode: (node: ts.CallExpression) => boolean;

                                                                                                                                                                                                                                                                              class ChainNodeParser

                                                                                                                                                                                                                                                                              class ChainNodeParser implements SubNodeParser, MutableParser {}

                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                constructor(typeChecker: ts.TypeChecker, nodeParsers: SubNodeParser[]);

                                                                                                                                                                                                                                                                                  property nodeParsers

                                                                                                                                                                                                                                                                                  protected nodeParsers: SubNodeParser[];

                                                                                                                                                                                                                                                                                    property typeCaches

                                                                                                                                                                                                                                                                                    protected readonly typeCaches: WeakMap<ts.Node, Map<string, BaseType>>;

                                                                                                                                                                                                                                                                                      property typeChecker

                                                                                                                                                                                                                                                                                      protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                        method addNodeParser

                                                                                                                                                                                                                                                                                        addNodeParser: (nodeParser: SubNodeParser) => this;

                                                                                                                                                                                                                                                                                          method createType

                                                                                                                                                                                                                                                                                          createType: (
                                                                                                                                                                                                                                                                                          node: ts.Node,
                                                                                                                                                                                                                                                                                          context: Context,
                                                                                                                                                                                                                                                                                          reference?: ReferenceType
                                                                                                                                                                                                                                                                                          ) => BaseType;

                                                                                                                                                                                                                                                                                            method getNodeParser

                                                                                                                                                                                                                                                                                            protected getNodeParser: (node: ts.Node) => SubNodeParser;

                                                                                                                                                                                                                                                                                              method supportsNode

                                                                                                                                                                                                                                                                                              supportsNode: (node: ts.Node) => boolean;

                                                                                                                                                                                                                                                                                                class ChainTypeFormatter

                                                                                                                                                                                                                                                                                                class ChainTypeFormatter implements SubTypeFormatter, MutableTypeFormatter {}

                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                  constructor(typeFormatters: SubTypeFormatter[]);

                                                                                                                                                                                                                                                                                                    property typeFormatters

                                                                                                                                                                                                                                                                                                    protected typeFormatters: SubTypeFormatter[];

                                                                                                                                                                                                                                                                                                      method addTypeFormatter

                                                                                                                                                                                                                                                                                                      addTypeFormatter: (typeFormatter: SubTypeFormatter) => this;

                                                                                                                                                                                                                                                                                                        method getChildren

                                                                                                                                                                                                                                                                                                        getChildren: (type: BaseType) => BaseType[];

                                                                                                                                                                                                                                                                                                          method getDefinition

                                                                                                                                                                                                                                                                                                          getDefinition: (type: BaseType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                            method getTypeFormatter

                                                                                                                                                                                                                                                                                                            protected getTypeFormatter: (type: BaseType) => SubTypeFormatter;

                                                                                                                                                                                                                                                                                                              method supportsType

                                                                                                                                                                                                                                                                                                              supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                class CircularReferenceNodeParser

                                                                                                                                                                                                                                                                                                                class CircularReferenceNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                  constructor(childNodeParser: SubNodeParser);

                                                                                                                                                                                                                                                                                                                    property childNodeParser

                                                                                                                                                                                                                                                                                                                    protected childNodeParser: SubNodeParser;

                                                                                                                                                                                                                                                                                                                      property circular

                                                                                                                                                                                                                                                                                                                      protected circular: Map<string, BaseType>;

                                                                                                                                                                                                                                                                                                                        method createType

                                                                                                                                                                                                                                                                                                                        createType: (node: ts.Node, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                          method supportsNode

                                                                                                                                                                                                                                                                                                                          supportsNode: (node: ts.Node) => boolean;

                                                                                                                                                                                                                                                                                                                            class CircularReferenceTypeFormatter

                                                                                                                                                                                                                                                                                                                            class CircularReferenceTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                              constructor(childTypeFormatter: SubTypeFormatter);

                                                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                                                protected children: Map<BaseType, BaseType[]>;

                                                                                                                                                                                                                                                                                                                                  property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                  protected childTypeFormatter: SubTypeFormatter;

                                                                                                                                                                                                                                                                                                                                    property definition

                                                                                                                                                                                                                                                                                                                                    protected definition: Map<BaseType, JSONSchema7>;

                                                                                                                                                                                                                                                                                                                                      method getChildren

                                                                                                                                                                                                                                                                                                                                      getChildren: (type: BaseType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                        method getDefinition

                                                                                                                                                                                                                                                                                                                                        getDefinition: (type: BaseType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                          method supportsType

                                                                                                                                                                                                                                                                                                                                          supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                            class ConditionalTypeNodeParser

                                                                                                                                                                                                                                                                                                                                            class ConditionalTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                              constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                property childNodeParser

                                                                                                                                                                                                                                                                                                                                                protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                  property typeChecker

                                                                                                                                                                                                                                                                                                                                                  protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                    method createSubContext

                                                                                                                                                                                                                                                                                                                                                    protected createSubContext: (
                                                                                                                                                                                                                                                                                                                                                    node: ts.ConditionalTypeNode,
                                                                                                                                                                                                                                                                                                                                                    parentContext: Context,
                                                                                                                                                                                                                                                                                                                                                    checkType?: CheckType,
                                                                                                                                                                                                                                                                                                                                                    inferMap?: Map<string, BaseType>
                                                                                                                                                                                                                                                                                                                                                    ) => Context;

                                                                                                                                                                                                                                                                                                                                                      method createType

                                                                                                                                                                                                                                                                                                                                                      createType: (node: ts.ConditionalTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                        method getTypeParameterName

                                                                                                                                                                                                                                                                                                                                                        protected getTypeParameterName: (node: ts.TypeNode) => string | null;

                                                                                                                                                                                                                                                                                                                                                          method supportsNode

                                                                                                                                                                                                                                                                                                                                                          supportsNode: (node: ts.ConditionalTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                            class ConstructorNodeParser

                                                                                                                                                                                                                                                                                                                                                            class ConstructorNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                              constructor(childNodeParser: NodeParser, functions: FunctionOptions);

                                                                                                                                                                                                                                                                                                                                                                property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                  property functions

                                                                                                                                                                                                                                                                                                                                                                  protected functions: FunctionOptions;

                                                                                                                                                                                                                                                                                                                                                                    method createType

                                                                                                                                                                                                                                                                                                                                                                    createType: (node: ts.ConstructorTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                      method supportsNode

                                                                                                                                                                                                                                                                                                                                                                      supportsNode: (node: ts.TypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                        class Context

                                                                                                                                                                                                                                                                                                                                                                        class Context {}

                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                          constructor(reference?: ts.Node);

                                                                                                                                                                                                                                                                                                                                                                            method getArgument

                                                                                                                                                                                                                                                                                                                                                                            getArgument: (parameterName: string) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                              method getArguments

                                                                                                                                                                                                                                                                                                                                                                              getArguments: () => readonly BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                method getCacheKey

                                                                                                                                                                                                                                                                                                                                                                                getCacheKey: () => string;

                                                                                                                                                                                                                                                                                                                                                                                  method getParameters

                                                                                                                                                                                                                                                                                                                                                                                  getParameters: () => readonly string[];

                                                                                                                                                                                                                                                                                                                                                                                    method getReference

                                                                                                                                                                                                                                                                                                                                                                                    getReference: () => ts.Node | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      method pushArgument

                                                                                                                                                                                                                                                                                                                                                                                      pushArgument: (argumentType: BaseType) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method pushParameter

                                                                                                                                                                                                                                                                                                                                                                                        pushParameter: (parameterName: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                          method setDefault

                                                                                                                                                                                                                                                                                                                                                                                          setDefault: (parameterName: string, argumentType: BaseType) => void;

                                                                                                                                                                                                                                                                                                                                                                                            class DefinitionError

                                                                                                                                                                                                                                                                                                                                                                                            class DefinitionError extends BaseError {}

                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                              constructor(messageText: string, definition: JSONSchema7);

                                                                                                                                                                                                                                                                                                                                                                                                property definition

                                                                                                                                                                                                                                                                                                                                                                                                readonly definition: JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                  class DefinitionType

                                                                                                                                                                                                                                                                                                                                                                                                  class DefinitionType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                    constructor(name: string, type: BaseType);

                                                                                                                                                                                                                                                                                                                                                                                                      method getId

                                                                                                                                                                                                                                                                                                                                                                                                      getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                        method getName

                                                                                                                                                                                                                                                                                                                                                                                                        getName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                          method getType

                                                                                                                                                                                                                                                                                                                                                                                                          getType: () => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                            class DefinitionTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                            class DefinitionTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                              constructor(childTypeFormatter: TypeFormatter, encodeRefs: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                  property encodeRefs

                                                                                                                                                                                                                                                                                                                                                                                                                  protected encodeRefs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                    method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                    getChildren: (type: DefinitionType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                      method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                      getDefinition: (type: DefinitionType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                        supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                          class EnumNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                          class EnumNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(typeChecker: ts.TypeChecker);

                                                                                                                                                                                                                                                                                                                                                                                                                              property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                              protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                createType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                node: ts.EnumDeclaration | ts.EnumMember,
                                                                                                                                                                                                                                                                                                                                                                                                                                context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method getMemberValue

                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getMemberValue: (member: ts.EnumMember, index: number) => EnumValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method parseInitializer

                                                                                                                                                                                                                                                                                                                                                                                                                                    protected parseInitializer: (initializer: ts.Node) => EnumValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                      supportsNode: (node: ts.EnumDeclaration | ts.EnumMember) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                        class EnumType

                                                                                                                                                                                                                                                                                                                                                                                                                                        class EnumType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(id: string, values: readonly EnumValue[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                            getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method getTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                              getTypes: () => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                method getValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                getValues: () => readonly EnumValue[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class EnumTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                  class EnumTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                    getChildren: (type: EnumType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                      getDefinition: (type: EnumType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ExpectationFailedError

                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ExpectationFailedError extends BaseError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(messageText: string, node?: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property node

                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly node?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ExposeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ExposeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeChecker: ts.TypeChecker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  subNodeParser: SubNodeParser,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expose: 'all' | 'none' | 'export',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  jsDoc: 'none' | 'extended' | 'basic'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property expose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected expose: 'all' | 'none' | 'export';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property jsDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected jsDoc: 'none' | 'extended' | 'basic';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property subNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected subNodeParser: SubNodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: ts.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            context: Context,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reference?: ReferenceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDefinitionName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getDefinitionName: (node: ts.Node, context: Context) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isExportNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected isExportNode: (node: ts.Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  supportsNode: (node: ts.Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ExpressionWithTypeArgumentsNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ExpressionWithTypeArgumentsNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createSubContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected createSubContext: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: ts.ExpressionWithTypeArguments,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parentContext: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Context;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createType: (node: ts.ExpressionWithTypeArguments, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                supportsNode: (node: ts.ExpressionWithTypeArguments) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ExtendedAnnotationsReader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ExtendedAnnotationsReader extends BasicAnnotationsReader {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typeChecker: ts.TypeChecker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extraTags?: Set<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    markdownDescription?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getAnnotations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getAnnotations: (node: ts.Node) => Annotations | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isNullable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isNullable: (node: ts.Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class FunctionNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class FunctionNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(childNodeParser: NodeParser, functions: FunctionOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected functions: FunctionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ts.FunctionTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ts.FunctionExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ts.FunctionDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ts.ArrowFunction,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supportsNode: (node: ts.Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class FunctionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class FunctionType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(node?: any, namedArguments?: ObjectType);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property namedArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected namedArguments?: ObjectType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getComment: () => string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getNamedArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getNamedArguments: () => ObjectType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class FunctionTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class FunctionTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(childTypeFormatter: TypeFormatter, functions: FunctionOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected functions: FunctionOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getChildren: (type: FunctionType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDefinition: (type: FunctionType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class HiddenNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class HiddenNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(typeChecker: ts.TypeChecker);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createType: (_node: ts.KeywordTypeNode, _context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class HiddenType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class HiddenType extends NeverType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class HiddenTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class HiddenTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChildren: (type: HiddenType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDefinition: (type: HiddenType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IndexedAccessTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IndexedAccessTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createType: (node: ts.IndexedAccessTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                supportsNode: (node: ts.TypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class InterfaceAndClassNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class InterfaceAndClassNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typeChecker: ts.TypeChecker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    childNodeParser: NodeParser,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    additionalProperties: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property additionalProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected readonly additionalProperties: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: ts.InterfaceDeclaration | ts.ClassDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            context: Context,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reference?: ReferenceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getAdditionalProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getAdditionalProperties: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: ts.InterfaceDeclaration | ts.ClassDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => BaseType | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getArrayItemType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected getArrayItemType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: ts.InterfaceDeclaration | ts.ClassDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ts.TypeNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getBaseTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getBaseTypes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: ts.InterfaceDeclaration | ts.ClassDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected getProperties: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ts.InterfaceDeclaration | ts.ClassDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ObjectProperty[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPropertyName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected getPropertyName: (propertyName: PropertyName) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getTypeId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected getTypeId: (node: ts.Node, context: Context) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          supportsNode: (node: ts.InterfaceDeclaration | ts.ClassDeclaration) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class IntersectionNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class IntersectionNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createType: (node: ts.IntersectionTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      supportsNode: (node: ts.IntersectionTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class IntersectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class IntersectionType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(types: BaseType[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getTypes: () => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class IntersectionTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class IntersectionTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(childTypeFormatter: TypeFormatter);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getChildren: (type: IntersectionType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDefinition: (type: IntersectionType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class IntrinsicNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class IntrinsicNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createType: (node: ts.KeywordTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JsonTypeError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JsonTypeError extends BaseError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(messageText: string, type: BaseType);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly type: BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class LiteralNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class LiteralNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createType: (node: ts.LiteralTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                supportsNode: (node: ts.LiteralTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class LiteralType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class LiteralType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(value: LiteralValue);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getValue: () => LiteralValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isString: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LiteralTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LiteralTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getChildren: (type: LiteralType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getDefinition: (type: LiteralType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class LiteralUnionTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class LiteralUnionTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getChildren: (type: UnionType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDefinition: (type: UnionType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LogicError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LogicError extends BaseError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(node: ts.Node, messageText: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly node: ts.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MappedTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class MappedTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(childNodeParser: NodeParser, additionalProperties: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property additionalProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected readonly additionalProperties: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createSubContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected createSubContext: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: ts.MappedTypeNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: LiteralType | StringType | NumberType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parentContext: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Context;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createType: (node: ts.MappedTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getAdditionalProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getAdditionalProperties: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: ts.MappedTypeNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keyListType: UnionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => BaseType | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected getProperties: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: ts.MappedTypeNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                keyListType: UnionType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ObjectProperty[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getValues: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: ts.MappedTypeNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  keyListType: EnumType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => ObjectProperty[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method mapKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected mapKey: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ts.MappedTypeNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rawKey: LiteralType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      supportsNode: (node: ts.MappedTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MultipleDefinitionsError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MultipleDefinitionsError extends BaseError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(name: string, defA: BaseType, defB?: BaseType);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly defA: BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly defB?: BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class NeverType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class NeverType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NeverTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NeverTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getChildren: (type: NeverType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDefinition: (type: NeverType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class NeverTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class NeverTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createType: (_node: ts.KeywordTypeNode, _context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class NullLiteralNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class NullLiteralNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createType: (node: ts.NullLiteral, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsNode: (node: ts.NullLiteral) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class NullType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class NullType extends PrimitiveType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class NullTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class NullTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChildren: (type: NullType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDefinition: (type: NullType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NumberLiteralNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NumberLiteralNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createType: (node: ts.NumericLiteral, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          supportsNode: (node: ts.NumericLiteral) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class NumberType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class NumberType extends PrimitiveType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class NumberTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class NumberTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getChildren: (type: NumberType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getDefinition: (type: NumberType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class NumberTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class NumberTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createType: (node: ts.KeywordTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ObjectLiteralExpressionNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ObjectLiteralExpressionNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createType: (node: ts.ObjectLiteralExpression, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      supportsNode: (node: ts.ObjectLiteralExpression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ObjectProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ObjectProperty {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(name: string, type: BaseType, required: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getType: () => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isRequired

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isRequired: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ObjectType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ObjectType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    baseTypes: readonly BaseType[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    properties: readonly ObjectProperty[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    additionalProperties: boolean | BaseType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nonPrimitive?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getAdditionalProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getAdditionalProperties: () => BaseType | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBaseTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getBaseTypes: () => readonly BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getNonPrimitive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getNonPrimitive: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getProperties: () => readonly ObjectProperty[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ObjectTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ObjectTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(childTypeFormatter: TypeFormatter);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getChildren: (type: ObjectType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDefinition: (type: ObjectType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getObjectDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getObjectDefinition: (type: ObjectType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method prepareObjectProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected prepareObjectProperty: (property: ObjectProperty) => ObjectProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ObjectTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ObjectTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createType: (node: ts.KeywordTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class OptionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class OptionalType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(item: BaseType);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getType: () => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class OptionalTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class OptionalTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(childTypeFormatter: TypeFormatter);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getChildren: (type: OptionalType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getDefinition: (type: OptionalType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class OptionalTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class OptionalTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createType: (node: ts.OptionalTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  supportsNode: (node: ts.OptionalTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ParameterParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ParameterParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createType: (node: ts.FunctionTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            supportsNode: (node: ts.ParameterDeclaration) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ParenthesizedNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ParenthesizedNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createType: (node: ts.ParenthesizedTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      supportsNode: (node: ts.ParenthesizedTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PrefixUnaryExpressionNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PrefixUnaryExpressionNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createType: (node: ts.PrefixUnaryExpression, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                supportsNode: (node: ts.PrefixUnaryExpression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class PrimitiveType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract class PrimitiveType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class PrimitiveUnionTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class PrimitiveUnionTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getChildren: (type: UnionType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDefinition: (type: UnionType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPrimitiveType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getPrimitiveType: (item: BaseType) => JSONSchema7TypeName;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isPrimitiveUnion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected isPrimitiveUnion: (type: UnionType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class PropertyAccessExpressionParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class PropertyAccessExpressionParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createType: (node: ts.PropertyAccessExpression, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          supportsNode: (node: ts.PropertyAccessExpression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ReferenceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ReferenceType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getType: () => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method hasType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hasType: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setId: (id: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setName: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setType: (type: BaseType) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ReferenceTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ReferenceTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(childTypeFormatter: TypeFormatter, encodeRefs: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property encodeRefs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected encodeRefs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getChildren: (type: ReferenceType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getDefinition: (type: ReferenceType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RestType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(item: ArrayType | InferType | TupleType, title?: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getTitle: () => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getType: () => ArrayType | InferType | TupleType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class RestTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class RestTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(childTypeFormatter: TypeFormatter);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getChildren: (type: RestType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDefinition: (type: RestType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class RestTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class RestTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createType: (node: ts.RestTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsNode: (node: ts.RestTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RootlessError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class RootlessError extends BaseError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(fullName: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property fullName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly fullName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SchemaGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SchemaGenerator {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  program: ts.Program,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nodeParser: NodeParser,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeFormatter: TypeFormatter,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  config?: Config
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected readonly config?: Config;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property nodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected readonly nodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected readonly program: ts.Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property typeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected readonly typeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method appendRootChildDefinitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected appendRootChildDefinitions: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rootType: BaseType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            childDefinitions: StringMap<Definition>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method appendTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected appendTypes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceFiles: readonly ts.SourceFile[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeChecker: ts.TypeChecker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              types: Map<string, ts.Node>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createSchema: (fullName?: string) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createSchemaFromNodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createSchemaFromNodes: (rootNodes: ts.Node[]) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method findNamedNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected findNamedNode: (fullName: string) => ts.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getFullName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected getFullName: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: ts.Declaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeChecker: ts.TypeChecker
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getRootNodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected getRootNodes: (fullName: string | undefined) => ts.Node[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getRootTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getRootTypeDefinition: (rootType: BaseType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method inspectNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected inspectNode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: ts.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typeChecker: ts.TypeChecker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            allTypes: Map<string, ts.Node>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isExportType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected isExportType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ts.InterfaceDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ts.ClassDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ts.EnumDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ts.TypeAliasDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isGenericType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected isGenericType: (node: ts.TypeAliasDeclaration) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method partitionFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected partitionFiles: () => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  projectFiles: ts.SourceFile[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  externalFiles: ts.SourceFile[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StringLiteralNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StringLiteralNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createType: (node: ts.StringLiteral, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsNode: (node: ts.StringLiteral) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class StringTemplateLiteralNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class StringTemplateLiteralNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: ts.NoSubstitutionTemplateLiteral | ts.TemplateLiteralTypeNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  supportsNode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: ts.NoSubstitutionTemplateLiteral | ts.TemplateLiteralTypeNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StringType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StringType extends PrimitiveType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(preserveLiterals?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property preserveLiterals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected preserveLiterals: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getPreserveLiterals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getPreserveLiterals: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class StringTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class StringTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getChildren: (type: StringType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDefinition: (type: StringType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class StringTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class StringTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createType: (node: ts.KeywordTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SymbolType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class SymbolType extends PrimitiveType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SymbolTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SymbolTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getChildren: (type: SymbolType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getDefinition: (type: SymbolType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SymbolTypeNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SymbolTypeNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createType: (node: ts.KeywordTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            supportsNode: (node: ts.KeywordTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TopRefNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TopRefNodeParser implements NodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(childNodeParser: NodeParser, fullName: string, topRef: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fullName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected fullName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property topRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected topRef: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createType: (node: ts.Node, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TupleNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TupleNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createType: (node: ts.TupleTypeNode, context: Context) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supportsNode: (node: ts.TupleTypeNode) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TupleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TupleType extends BaseType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(types: readonly BaseType[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getId: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getTypes: () => Readonly<Array<BaseType>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TupleTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TupleTypeFormatter implements SubTypeFormatter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(childTypeFormatter: TypeFormatter);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property childTypeFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected childTypeFormatter: TypeFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getChildren

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getChildren: (type: TupleType) => BaseType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getDefinition: (type: TupleType) => JSONSchema7;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsType: (type: BaseType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TypeAliasNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TypeAliasNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(typeChecker: ts.TypeChecker, childNodeParser: NodeParser);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: ts.TypeAliasDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  context: Context,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reference?: ReferenceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getTypeId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected getTypeId: (node: ts.TypeAliasDeclaration, context: Context) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getTypeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected getTypeName: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: ts.TypeAliasDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method supportsNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        supportsNode: (node: ts.TypeAliasDeclaration) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TypeLiteralNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TypeLiteralNodeParser implements SubNodeParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typeChecker: ts.TypeChecker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            childNodeParser: NodeParser,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            additionalProperties: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property additionalProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected readonly additionalProperties: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property childNodeParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected childNodeParser: NodeParser;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typeChecker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected typeChecker: ts.TypeChecker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method createType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ts.TypeLiteralNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context: Context,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reference?: ReferenceType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => BaseType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getAdditionalProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected getAdditionalProperties: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: ts.TypeLiteralNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => BaseType | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected getProperties: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: ts.TypeLiteralNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        context: Context
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => ObjectProperty[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPropertyName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getPropertyName: (propertyName: ts.PropertyName) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getTypeId