@teambit/semantics.entities.semantic-schema 0.0.0-e4ef0e951da794f03096a5cc407420f4cde8b878

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

@@ -0,0 +1,22 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { TemplateLiteralTypeSpanSchema } from './template-literal-type-span';
+export declare class TemplateLiteralTypeSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly head: string;
+    readonly templateSpans: TemplateLiteralTypeSpanSchema[];
+    constructor(location: SchemaLocation, head: string, templateSpans: TemplateLiteralTypeSpanSchema[]);
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        head: string;
+        templateSpans: {
+            literal: string;
+            type: Record<string, any>;
+        }[];
+    };
+    static fromObject(obj: Record<string, any>): TemplateLiteralTypeSchema;
+}

package/dist/schemas/template-literal-type.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TemplateLiteralTypeSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _templateLiteralTypeSpan() {
+  const data = require("./template-literal-type-span");
+  _templateLiteralTypeSpan = function () {
+    return data;
+  };
+  return data;
+}
+class TemplateLiteralTypeSchema extends _schemaNode().SchemaNode {
+  constructor(location, head, templateSpans) {
+    super();
+    this.location = location;
+    this.head = head;
+    this.templateSpans = templateSpans;
+  }
+  toString(options) {
+    const spans = this.templateSpans.map(span => span.toString(options)).join('');
+    return `${this.head}${spans}`;
+  }
+  toFullSignature(options) {
+    const spans = this.templateSpans.map(span => span.toFullSignature(options)).join('');
+    return `\`${this.head}${spans}\``;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      head: this.head,
+      templateSpans: this.templateSpans.map(span => span.toObject())
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const head = obj.head;
+    const templateSpans = obj.templateSpans.map(span => _templateLiteralTypeSpan().TemplateLiteralTypeSpanSchema.fromObject(span));
+    return new TemplateLiteralTypeSchema(location, head, templateSpans);
+  }
+}
+exports.TemplateLiteralTypeSchema = TemplateLiteralTypeSchema;
+
+//# sourceMappingURL=template-literal-type.js.map

package/dist/schemas/template-literal-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_templateLiteralTypeSpan","TemplateLiteralTypeSchema","SchemaNode","constructor","location","head","templateSpans","toString","options","spans","map","span","join","toFullSignature","toObject","fromObject","obj","TemplateLiteralTypeSpanSchema","exports"],"sources":["template-literal-type.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { TemplateLiteralTypeSpanSchema } from './template-literal-type-span';\n\nexport class TemplateLiteralTypeSchema extends SchemaNode {\n  readonly templateSpans: TemplateLiteralTypeSpanSchema[];\n\n  constructor(\n    readonly location: SchemaLocation,\n    readonly head: string,\n    templateSpans: TemplateLiteralTypeSpanSchema[]\n  ) {\n    super();\n    this.templateSpans = templateSpans;\n  }\n\n  toString(options?: { color?: boolean }) {\n    const spans = this.templateSpans.map((span) => span.toString(options)).join('');\n    return `${this.head}${spans}`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    const spans = this.templateSpans.map((span) => span.toFullSignature(options)).join('');\n    return `\\`${this.head}${spans}\\``;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      head: this.head,\n      templateSpans: this.templateSpans.map((span) => span.toObject()),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): TemplateLiteralTypeSchema {\n    const location = obj.location;\n    const head = obj.head;\n    const templateSpans = obj.templateSpans.map((span: any) => TemplateLiteralTypeSpanSchema.fromObject(span));\n    return new TemplateLiteralTypeSchema(location, head, templateSpans);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,yBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,wBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,yBAAyB,SAASC,wBAAU,CAAC;EAGxDC,WAAWA,CACAC,QAAwB,EACxBC,IAAY,EACrBC,aAA8C,EAC9C;IACA,KAAK,CAAC,CAAC;IAAC,KAJCF,QAAwB,GAAxBA,QAAwB;IAAA,KACxBC,IAAY,GAAZA,IAAY;IAIrB,IAAI,CAACC,aAAa,GAAGA,aAAa;EACpC;EAEAC,QAAQA,CAACC,OAA6B,EAAE;IACtC,MAAMC,KAAK,GAAG,IAAI,CAACH,aAAa,CAACI,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACJ,QAAQ,CAACC,OAAO,CAAC,CAAC,CAACI,IAAI,CAAC,EAAE,CAAC;IAC/E,OAAO,GAAG,IAAI,CAACP,IAAI,GAAGI,KAAK,EAAE;EAC/B;EAEAI,eAAeA,CAACL,OAAgC,EAAU;IACxD,MAAMC,KAAK,GAAG,IAAI,CAACH,aAAa,CAACI,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACE,eAAe,CAACL,OAAO,CAAC,CAAC,CAACI,IAAI,CAAC,EAAE,CAAC;IACtF,OAAO,KAAK,IAAI,CAACP,IAAI,GAAGI,KAAK,IAAI;EACnC;EAEAK,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBT,IAAI,EAAE,IAAI,CAACA,IAAI;MACfC,aAAa,EAAE,IAAI,CAACA,aAAa,CAACI,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACG,QAAQ,CAAC,CAAC;IACjE,CAAC;EACH;EAEA,OAAOC,UAAUA,CAACC,GAAwB,EAA6B;IACrE,MAAMZ,QAAQ,GAAGY,GAAG,CAACZ,QAAQ;IAC7B,MAAMC,IAAI,GAAGW,GAAG,CAACX,IAAI;IACrB,MAAMC,aAAa,GAAGU,GAAG,CAACV,aAAa,CAACI,GAAG,CAAEC,IAAS,IAAKM,wDAA6B,CAACF,UAAU,CAACJ,IAAI,CAAC,CAAC;IAC1G,OAAO,IAAIV,yBAAyB,CAACG,QAAQ,EAAEC,IAAI,EAAEC,aAAa,CAAC;EACrE;AACF;AAACY,OAAA,CAAAjB,yBAAA,GAAAA,yBAAA","ignoreList":[]}

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

@@ -0,0 +1,12 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+/**
+ * e.g. `class A { createA(): this {} }`
+ */
+export declare class ThisTypeSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly name: string;
+    constructor(location: SchemaLocation, name: string);
+    toString(): string;
+    toFullSignature(): string;
+    static fromObject(obj: Record<string, any>): ThisTypeSchema;
+}

package/dist/schemas/this-type.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ThisTypeSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * e.g. `class A { createA(): this {} }`
+ */
+class ThisTypeSchema extends _schemaNode().SchemaNode {
+  constructor(location, name) {
+    super();
+    this.location = location;
+    this.name = name;
+  }
+  toString() {
+    return this.name;
+  }
+  toFullSignature() {
+    return this.toString();
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const name = obj.name;
+    return new ThisTypeSchema(location, name);
+  }
+}
+exports.ThisTypeSchema = ThisTypeSchema;
+
+//# sourceMappingURL=this-type.js.map

package/dist/schemas/this-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","ThisTypeSchema","SchemaNode","constructor","location","name","toString","toFullSignature","fromObject","obj","exports"],"sources":["this-type.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\n\n/**\n * e.g. `class A { createA(): this {} }`\n */\nexport class ThisTypeSchema extends SchemaNode {\n  constructor(\n    readonly location: SchemaLocation,\n    readonly name: string\n  ) {\n    super();\n  }\n\n  toString() {\n    return this.name;\n  }\n\n  toFullSignature() {\n    return this.toString();\n  }\n\n  static fromObject(obj: Record<string, any>): ThisTypeSchema {\n    const location = obj.location;\n    const name = obj.name;\n    return new ThisTypeSchema(location, name);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA;AACA;AACA;AACO,MAAME,cAAc,SAASC,wBAAU,CAAC;EAC7CC,WAAWA,CACAC,QAAwB,EACxBC,IAAY,EACrB;IACA,KAAK,CAAC,CAAC;IAAC,KAHCD,QAAwB,GAAxBA,QAAwB;IAAA,KACxBC,IAAY,GAAZA,IAAY;EAGvB;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO,IAAI,CAACD,IAAI;EAClB;EAEAE,eAAeA,CAAA,EAAG;IAChB,OAAO,IAAI,CAACD,QAAQ,CAAC,CAAC;EACxB;EAEA,OAAOE,UAAUA,CAACC,GAAwB,EAAkB;IAC1D,MAAML,QAAQ,GAAGK,GAAG,CAACL,QAAQ;IAC7B,MAAMC,IAAI,GAAGI,GAAG,CAACJ,IAAI;IACrB,OAAO,IAAIJ,cAAc,CAACG,QAAQ,EAAEC,IAAI,CAAC;EAC3C;AACF;AAACK,OAAA,CAAAT,cAAA,GAAAA,cAAA","ignoreList":[]}

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

@@ -0,0 +1,16 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+export declare class TupleTypeSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly elements: SchemaNode[];
+    constructor(location: SchemaLocation, elements: SchemaNode[]);
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        elements: Record<string, any>[];
+    };
+    static fromObject(obj: Record<string, any>): TupleTypeSchema;
+}

package/dist/schemas/tuple-type.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TupleTypeSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+class TupleTypeSchema extends _schemaNode().SchemaNode {
+  constructor(location, elements) {
+    super();
+    this.location = location;
+    this.elements = elements;
+  }
+  toString(options) {
+    return `[${this.elements.map(elem => elem.toString(options)).join(', ')}]`;
+  }
+  toFullSignature(options) {
+    return `[${this.elements.map(elem => elem.toFullSignature(options)).join(', ')}]`;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      elements: this.elements.map(elem => elem.toObject())
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const elements = obj.elements.map(elem => _schemaRegistry().SchemaRegistry.fromObject(elem));
+    return new TupleTypeSchema(location, elements);
+  }
+}
+exports.TupleTypeSchema = TupleTypeSchema;
+
+//# sourceMappingURL=tuple-type.js.map

package/dist/schemas/tuple-type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_schemaRegistry","TupleTypeSchema","SchemaNode","constructor","location","elements","toString","options","map","elem","join","toFullSignature","toObject","fromObject","obj","SchemaRegistry","exports"],"sources":["tuple-type.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { SchemaRegistry } from '../schema-registry';\n\nexport class TupleTypeSchema extends SchemaNode {\n  readonly elements: SchemaNode[];\n\n  constructor(\n    readonly location: SchemaLocation,\n    elements: SchemaNode[]\n  ) {\n    super();\n    this.elements = elements;\n  }\n\n  toString(options?: { color?: boolean }) {\n    return `[${this.elements.map((elem) => elem.toString(options)).join(', ')}]`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    return `[${this.elements.map((elem) => elem.toFullSignature(options)).join(', ')}]`;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      elements: this.elements.map((elem) => elem.toObject()),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): TupleTypeSchema {\n    const location = obj.location;\n    const elements = obj.elements.map((elem: any) => SchemaRegistry.fromObject(elem));\n    return new TupleTypeSchema(location, elements);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,gBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,eAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,eAAe,SAASC,wBAAU,CAAC;EAG9CC,WAAWA,CACAC,QAAwB,EACjCC,QAAsB,EACtB;IACA,KAAK,CAAC,CAAC;IAAC,KAHCD,QAAwB,GAAxBA,QAAwB;IAIjC,IAAI,CAACC,QAAQ,GAAGA,QAAQ;EAC1B;EAEAC,QAAQA,CAACC,OAA6B,EAAE;IACtC,OAAO,IAAI,IAAI,CAACF,QAAQ,CAACG,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACH,QAAQ,CAACC,OAAO,CAAC,CAAC,CAACG,IAAI,CAAC,IAAI,CAAC,GAAG;EAC9E;EAEAC,eAAeA,CAACJ,OAAgC,EAAU;IACxD,OAAO,IAAI,IAAI,CAACF,QAAQ,CAACG,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACE,eAAe,CAACJ,OAAO,CAAC,CAAC,CAACG,IAAI,CAAC,IAAI,CAAC,GAAG;EACrF;EAEAE,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBP,QAAQ,EAAE,IAAI,CAACA,QAAQ,CAACG,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACG,QAAQ,CAAC,CAAC;IACvD,CAAC;EACH;EAEA,OAAOC,UAAUA,CAACC,GAAwB,EAAmB;IAC3D,MAAMV,QAAQ,GAAGU,GAAG,CAACV,QAAQ;IAC7B,MAAMC,QAAQ,GAAGS,GAAG,CAACT,QAAQ,CAACG,GAAG,CAAEC,IAAS,IAAKM,gCAAc,CAACF,UAAU,CAACJ,IAAI,CAAC,CAAC;IACjF,OAAO,IAAIR,eAAe,CAACG,QAAQ,EAAEC,QAAQ,CAAC;EAChD;AACF;AAACW,OAAA,CAAAf,eAAA,GAAAA,eAAA","ignoreList":[]}

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

@@ -0,0 +1,17 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+export declare class TypeArraySchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly type: SchemaNode;
+    constructor(location: SchemaLocation, type: SchemaNode);
+    getNodes(): SchemaNode[];
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        type: Record<string, any>;
+    };
+    static fromObject(obj: Record<string, any>): TypeArraySchema;
+}

package/dist/schemas/type-array.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeArraySchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+class TypeArraySchema extends _schemaNode().SchemaNode {
+  constructor(location, type) {
+    super();
+    this.location = location;
+    this.type = type;
+  }
+  getNodes() {
+    return [this.type];
+  }
+  toString(options) {
+    return `${this.type.toString(options)}[]`;
+  }
+  toFullSignature(options) {
+    return `${this.type.toFullSignature(options)}[]`;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type.toObject()
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const type = _schemaRegistry().SchemaRegistry.fromObject(obj.type);
+    return new TypeArraySchema(location, type);
+  }
+}
+exports.TypeArraySchema = TypeArraySchema;
+
+//# sourceMappingURL=type-array.js.map

package/dist/schemas/type-array.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_schemaRegistry","TypeArraySchema","SchemaNode","constructor","location","type","getNodes","toString","options","toFullSignature","toObject","fromObject","obj","SchemaRegistry","exports"],"sources":["type-array.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { SchemaRegistry } from '../schema-registry';\n\nexport class TypeArraySchema extends SchemaNode {\n  readonly type: SchemaNode;\n\n  constructor(\n    readonly location: SchemaLocation,\n    type: SchemaNode\n  ) {\n    super();\n    this.type = type;\n  }\n\n  getNodes() {\n    return [this.type];\n  }\n\n  toString(options?: { color?: boolean }) {\n    return `${this.type.toString(options)}[]`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    return `${this.type.toFullSignature(options)}[]`;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      type: this.type.toObject(),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): TypeArraySchema {\n    const location = obj.location;\n    const type = SchemaRegistry.fromObject(obj.type);\n    return new TypeArraySchema(location, type);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,gBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,eAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,eAAe,SAASC,wBAAU,CAAC;EAG9CC,WAAWA,CACAC,QAAwB,EACjCC,IAAgB,EAChB;IACA,KAAK,CAAC,CAAC;IAAC,KAHCD,QAAwB,GAAxBA,QAAwB;IAIjC,IAAI,CAACC,IAAI,GAAGA,IAAI;EAClB;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO,CAAC,IAAI,CAACD,IAAI,CAAC;EACpB;EAEAE,QAAQA,CAACC,OAA6B,EAAE;IACtC,OAAO,GAAG,IAAI,CAACH,IAAI,CAACE,QAAQ,CAACC,OAAO,CAAC,IAAI;EAC3C;EAEAC,eAAeA,CAACD,OAAgC,EAAU;IACxD,OAAO,GAAG,IAAI,CAACH,IAAI,CAACI,eAAe,CAACD,OAAO,CAAC,IAAI;EAClD;EAEAE,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBL,IAAI,EAAE,IAAI,CAACA,IAAI,CAACK,QAAQ,CAAC;IAC3B,CAAC;EACH;EAEA,OAAOC,UAAUA,CAACC,GAAwB,EAAmB;IAC3D,MAAMR,QAAQ,GAAGQ,GAAG,CAACR,QAAQ;IAC7B,MAAMC,IAAI,GAAGQ,gCAAc,CAACF,UAAU,CAACC,GAAG,CAACP,IAAI,CAAC;IAChD,OAAO,IAAIJ,eAAe,CAACG,QAAQ,EAAEC,IAAI,CAAC;EAC5C;AACF;AAACS,OAAA,CAAAb,eAAA,GAAAA,eAAA","ignoreList":[]}

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

@@ -0,0 +1,17 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+export declare class TypeIntersectionSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly types: SchemaNode[];
+    constructor(location: SchemaLocation, types: SchemaNode[]);
+    getNodes(): SchemaNode[];
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        types: Record<string, any>[];
+    };
+    static fromObject(obj: Record<string, any>): TypeIntersectionSchema;
+}

package/dist/schemas/type-intersection.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeIntersectionSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+class TypeIntersectionSchema extends _schemaNode().SchemaNode {
+  constructor(location, types) {
+    super();
+    this.location = location;
+    this.types = types;
+  }
+  getNodes() {
+    return this.types;
+  }
+  toString(options) {
+    return `${this.types.map(type => type.toString(options)).join(' & ')}`;
+  }
+  toFullSignature(options) {
+    return this.types.map(type => type.toFullSignature(options)).join(' & ');
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      types: this.types.map(type => type.toObject())
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const types = obj.types.map(type => _schemaRegistry().SchemaRegistry.fromObject(type));
+    return new TypeIntersectionSchema(location, types);
+  }
+}
+exports.TypeIntersectionSchema = TypeIntersectionSchema;
+
+//# sourceMappingURL=type-intersection.js.map

package/dist/schemas/type-intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_schemaRegistry","TypeIntersectionSchema","SchemaNode","constructor","location","types","getNodes","toString","options","map","type","join","toFullSignature","toObject","fromObject","obj","SchemaRegistry","exports"],"sources":["type-intersection.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { SchemaRegistry } from '../schema-registry';\n\nexport class TypeIntersectionSchema extends SchemaNode {\n  readonly types: SchemaNode[];\n\n  constructor(\n    readonly location: SchemaLocation,\n    types: SchemaNode[]\n  ) {\n    super();\n    this.types = types;\n  }\n\n  getNodes() {\n    return this.types;\n  }\n\n  toString(options?: { color?: boolean }) {\n    return `${this.types.map((type) => type.toString(options)).join(' & ')}`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    return this.types.map((type) => type.toFullSignature(options)).join(' & ');\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      types: this.types.map((type) => type.toObject()),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): TypeIntersectionSchema {\n    const location = obj.location;\n    const types = obj.types.map((type: any) => SchemaRegistry.fromObject(type));\n    return new TypeIntersectionSchema(location, types);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,gBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,eAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,sBAAsB,SAASC,wBAAU,CAAC;EAGrDC,WAAWA,CACAC,QAAwB,EACjCC,KAAmB,EACnB;IACA,KAAK,CAAC,CAAC;IAAC,KAHCD,QAAwB,GAAxBA,QAAwB;IAIjC,IAAI,CAACC,KAAK,GAAGA,KAAK;EACpB;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO,IAAI,CAACD,KAAK;EACnB;EAEAE,QAAQA,CAACC,OAA6B,EAAE;IACtC,OAAO,GAAG,IAAI,CAACH,KAAK,CAACI,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACH,QAAQ,CAACC,OAAO,CAAC,CAAC,CAACG,IAAI,CAAC,KAAK,CAAC,EAAE;EAC1E;EAEAC,eAAeA,CAACJ,OAAgC,EAAU;IACxD,OAAO,IAAI,CAACH,KAAK,CAACI,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACE,eAAe,CAACJ,OAAO,CAAC,CAAC,CAACG,IAAI,CAAC,KAAK,CAAC;EAC5E;EAEAE,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBR,KAAK,EAAE,IAAI,CAACA,KAAK,CAACI,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACG,QAAQ,CAAC,CAAC;IACjD,CAAC;EACH;EAEA,OAAOC,UAAUA,CAACC,GAAwB,EAA0B;IAClE,MAAMX,QAAQ,GAAGW,GAAG,CAACX,QAAQ;IAC7B,MAAMC,KAAK,GAAGU,GAAG,CAACV,KAAK,CAACI,GAAG,CAAEC,IAAS,IAAKM,gCAAc,CAACF,UAAU,CAACJ,IAAI,CAAC,CAAC;IAC3E,OAAO,IAAIT,sBAAsB,CAACG,QAAQ,EAAEC,KAAK,CAAC;EACpD;AACF;AAACY,OAAA,CAAAhB,sBAAA,GAAAA,sBAAA","ignoreList":[]}

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

@@ -0,0 +1,18 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+/**
+ * e.g. `{ a: string; b: number }`
+ */
+export declare class TypeLiteralSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly members: SchemaNode[];
+    constructor(location: SchemaLocation, members: SchemaNode[]);
+    getNodes(): SchemaNode[];
+    toString(): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        members: Record<string, any>[];
+    };
+    static fromObject(obj: Record<string, any>): TypeLiteralSchema;
+}

package/dist/schemas/type-literal.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeLiteralSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * e.g. `{ a: string; b: number }`
+ */
+class TypeLiteralSchema extends _schemaNode().SchemaNode {
+  constructor(location, members) {
+    super();
+    this.location = location;
+    this.members = members;
+  }
+  getNodes() {
+    return this.members;
+  }
+  toString() {
+    return `{ ${this.members.map(type => type.toString()).join('; ')} }`;
+  }
+  toFullSignature(options) {
+    const indent = level => '  '.repeat(level);
+    const level = 0;
+    let signature = '';
+    signature += '{\n';
+    this.members.forEach(member => {
+      const memberSignature = member.toFullSignature(options);
+      const memberLines = memberSignature.split('\n');
+      const indentedLines = memberLines.map(line => indent(level + 1) + line);
+      signature += indentedLines.join('\n') + '\n';
+    });
+    signature += indent(level) + '}';
+    return signature;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      members: this.members.map(type => type.toObject())
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const members = obj.members.map(type => _schemaRegistry().SchemaRegistry.fromObject(type));
+    return new TypeLiteralSchema(location, members);
+  }
+}
+exports.TypeLiteralSchema = TypeLiteralSchema;
+
+//# sourceMappingURL=type-literal.js.map

package/dist/schemas/type-literal.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_schemaRegistry","TypeLiteralSchema","SchemaNode","constructor","location","members","getNodes","toString","map","type","join","toFullSignature","options","indent","level","repeat","signature","forEach","member","memberSignature","memberLines","split","indentedLines","line","toObject","fromObject","obj","SchemaRegistry","exports"],"sources":["type-literal.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { SchemaRegistry } from '../schema-registry';\n\n/**\n * e.g. `{ a: string; b: number }`\n */\nexport class TypeLiteralSchema extends SchemaNode {\n  readonly members: SchemaNode[];\n\n  constructor(\n    readonly location: SchemaLocation,\n    members: SchemaNode[]\n  ) {\n    super();\n    this.members = members;\n  }\n\n  getNodes() {\n    return this.members;\n  }\n\n  toString() {\n    return `{ ${this.members.map((type) => type.toString()).join('; ')} }`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    const indent = (level: number) => '  '.repeat(level);\n    const level = 0;\n    let signature = '';\n\n    signature += '{\\n';\n\n    this.members.forEach((member) => {\n      const memberSignature = member.toFullSignature(options);\n\n      const memberLines = memberSignature.split('\\n');\n\n      const indentedLines = memberLines.map((line) => indent(level + 1) + line);\n\n      signature += indentedLines.join('\\n') + '\\n';\n    });\n\n    signature += indent(level) + '}';\n\n    return signature;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      members: this.members.map((type) => type.toObject()),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): TypeLiteralSchema {\n    const location = obj.location;\n    const members = obj.members.map((type: any) => SchemaRegistry.fromObject(type));\n    return new TypeLiteralSchema(location, members);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,gBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,eAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA;AACA;AACA;AACO,MAAMG,iBAAiB,SAASC,wBAAU,CAAC;EAGhDC,WAAWA,CACAC,QAAwB,EACjCC,OAAqB,EACrB;IACA,KAAK,CAAC,CAAC;IAAC,KAHCD,QAAwB,GAAxBA,QAAwB;IAIjC,IAAI,CAACC,OAAO,GAAGA,OAAO;EACxB;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO,IAAI,CAACD,OAAO;EACrB;EAEAE,QAAQA,CAAA,EAAG;IACT,OAAO,KAAK,IAAI,CAACF,OAAO,CAACG,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACF,QAAQ,CAAC,CAAC,CAAC,CAACG,IAAI,CAAC,IAAI,CAAC,IAAI;EACxE;EAEAC,eAAeA,CAACC,OAAgC,EAAU;IACxD,MAAMC,MAAM,GAAIC,KAAa,IAAK,IAAI,CAACC,MAAM,CAACD,KAAK,CAAC;IACpD,MAAMA,KAAK,GAAG,CAAC;IACf,IAAIE,SAAS,GAAG,EAAE;IAElBA,SAAS,IAAI,KAAK;IAElB,IAAI,CAACX,OAAO,CAACY,OAAO,CAAEC,MAAM,IAAK;MAC/B,MAAMC,eAAe,GAAGD,MAAM,CAACP,eAAe,CAACC,OAAO,CAAC;MAEvD,MAAMQ,WAAW,GAAGD,eAAe,CAACE,KAAK,CAAC,IAAI,CAAC;MAE/C,MAAMC,aAAa,GAAGF,WAAW,CAACZ,GAAG,CAAEe,IAAI,IAAKV,MAAM,CAACC,KAAK,GAAG,CAAC,CAAC,GAAGS,IAAI,CAAC;MAEzEP,SAAS,IAAIM,aAAa,CAACZ,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI;IAC9C,CAAC,CAAC;IAEFM,SAAS,IAAIH,MAAM,CAACC,KAAK,CAAC,GAAG,GAAG;IAEhC,OAAOE,SAAS;EAClB;EAEAQ,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBnB,OAAO,EAAE,IAAI,CAACA,OAAO,CAACG,GAAG,CAAEC,IAAI,IAAKA,IAAI,CAACe,QAAQ,CAAC,CAAC;IACrD,CAAC;EACH;EAEA,OAAOC,UAAUA,CAACC,GAAwB,EAAqB;IAC7D,MAAMtB,QAAQ,GAAGsB,GAAG,CAACtB,QAAQ;IAC7B,MAAMC,OAAO,GAAGqB,GAAG,CAACrB,OAAO,CAACG,GAAG,CAAEC,IAAS,IAAKkB,gCAAc,CAACF,UAAU,CAAChB,IAAI,CAAC,CAAC;IAC/E,OAAO,IAAIR,iBAAiB,CAACG,QAAQ,EAAEC,OAAO,CAAC;EACjD;AACF;AAACuB,OAAA,CAAA3B,iBAAA,GAAAA,iBAAA","ignoreList":[]}

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

@@ -0,0 +1,19 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+export declare class TypeOperatorSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly name: string;
+    type: SchemaNode;
+    constructor(location: SchemaLocation, name: string, type: SchemaNode);
+    getNodes(): SchemaNode[];
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        name: string;
+        type: Record<string, any>;
+    };
+    static fromObject(obj: Record<string, any>): TypeOperatorSchema;
+}

package/dist/schemas/type-operator.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypeOperatorSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+class TypeOperatorSchema extends _schemaNode().SchemaNode {
+  constructor(location, name, type) {
+    super();
+    this.location = location;
+    this.name = name;
+    this.type = type;
+  }
+  getNodes() {
+    return [this.type];
+  }
+  toString(options) {
+    return `${this.name} ${this.type.toString(options)}`;
+  }
+  toFullSignature(options) {
+    return `${this.name} ${this.type.toFullSignature(options)}`;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type.toObject()
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const name = obj.name;
+    const type = _schemaRegistry().SchemaRegistry.fromObject(obj.type);
+    return new TypeOperatorSchema(location, name, type);
+  }
+}
+exports.TypeOperatorSchema = TypeOperatorSchema;
+
+//# sourceMappingURL=type-operator.js.map

package/dist/schemas/type-operator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_schemaRegistry","TypeOperatorSchema","SchemaNode","constructor","location","name","type","getNodes","toString","options","toFullSignature","toObject","fromObject","obj","SchemaRegistry","exports"],"sources":["type-operator.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { SchemaRegistry } from '../schema-registry';\n\nexport class TypeOperatorSchema extends SchemaNode {\n  type: SchemaNode;\n  constructor(\n    readonly location: SchemaLocation,\n    readonly name: string,\n    type: SchemaNode\n  ) {\n    super();\n    this.type = type;\n  }\n\n  getNodes() {\n    return [this.type];\n  }\n\n  toString(options?: { color?: boolean }) {\n    return `${this.name} ${this.type.toString(options)}`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    return `${this.name} ${this.type.toFullSignature(options)}`;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      name: this.name,\n      type: this.type.toObject(),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): TypeOperatorSchema {\n    const location = obj.location;\n    const name = obj.name;\n    const type = SchemaRegistry.fromObject(obj.type);\n    return new TypeOperatorSchema(location, name, type);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,gBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,eAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,kBAAkB,SAASC,wBAAU,CAAC;EAEjDC,WAAWA,CACAC,QAAwB,EACxBC,IAAY,EACrBC,IAAgB,EAChB;IACA,KAAK,CAAC,CAAC;IAAC,KAJCF,QAAwB,GAAxBA,QAAwB;IAAA,KACxBC,IAAY,GAAZA,IAAY;IAIrB,IAAI,CAACC,IAAI,GAAGA,IAAI;EAClB;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO,CAAC,IAAI,CAACD,IAAI,CAAC;EACpB;EAEAE,QAAQA,CAACC,OAA6B,EAAE;IACtC,OAAO,GAAG,IAAI,CAACJ,IAAI,IAAI,IAAI,CAACC,IAAI,CAACE,QAAQ,CAACC,OAAO,CAAC,EAAE;EACtD;EAEAC,eAAeA,CAACD,OAAgC,EAAU;IACxD,OAAO,GAAG,IAAI,CAACJ,IAAI,IAAI,IAAI,CAACC,IAAI,CAACI,eAAe,CAACD,OAAO,CAAC,EAAE;EAC7D;EAEAE,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBN,IAAI,EAAE,IAAI,CAACA,IAAI;MACfC,IAAI,EAAE,IAAI,CAACA,IAAI,CAACK,QAAQ,CAAC;IAC3B,CAAC;EACH;EAEA,OAAOC,UAAUA,CAACC,GAAwB,EAAsB;IAC9D,MAAMT,QAAQ,GAAGS,GAAG,CAACT,QAAQ;IAC7B,MAAMC,IAAI,GAAGQ,GAAG,CAACR,IAAI;IACrB,MAAMC,IAAI,GAAGQ,gCAAc,CAACF,UAAU,CAACC,GAAG,CAACP,IAAI,CAAC;IAChD,OAAO,IAAIL,kBAAkB,CAACG,QAAQ,EAAEC,IAAI,EAAEC,IAAI,CAAC;EACrD;AACF;AAACS,OAAA,CAAAd,kBAAA,GAAAA,kBAAA","ignoreList":[]}

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

@@ -0,0 +1,33 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+/**
+ * e.g. `function f(str: any): str is string {}`
+ *
+ * example when the type is empty:
+ * ```ts
+ * function assert(condition: any, msg?: string): asserts condition {
+ *  if (!condition) {
+ *   throw new AssertionError(msg);
+ *  }
+ * }
+ * ```
+ *
+ */
+export declare class TypePredicateSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly name: string;
+    readonly hasAssertsModifier: boolean;
+    readonly type?: SchemaNode;
+    constructor(location: SchemaLocation, name: string, type?: SchemaNode, hasAssertsModifier?: boolean);
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        name: string;
+        type: Record<string, any> | undefined;
+        hasAssertsModifier: boolean;
+    };
+    static fromObject(obj: Record<string, any>): TypePredicateSchema;
+}

package/dist/schemas/type-predicate.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TypePredicateSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * e.g. `function f(str: any): str is string {}`
+ *
+ * example when the type is empty:
+ * ```ts
+ * function assert(condition: any, msg?: string): asserts condition {
+ *  if (!condition) {
+ *   throw new AssertionError(msg);
+ *  }
+ * }
+ * ```
+ *
+ */
+class TypePredicateSchema extends _schemaNode().SchemaNode {
+  constructor(location, name, type, hasAssertsModifier = false) {
+    super();
+    this.location = location;
+    this.name = name;
+    this.hasAssertsModifier = hasAssertsModifier;
+    this.type = type;
+  }
+  toString(options) {
+    const assertsKeyword = this.hasAssertsModifier ? 'asserts ' : '';
+    const typeStr = this.type ? ` is ${this.type.toString(options)}` : '';
+    return assertsKeyword + this.name + typeStr;
+  }
+  toFullSignature(options) {
+    const assertsKeyword = this.hasAssertsModifier ? 'asserts ' : '';
+    const typeSignature = this.type ? ` is ${this.type.toFullSignature(options)}` : '';
+    let signature = `${assertsKeyword}${this.name}${typeSignature}`;
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+    return signature;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type?.toObject(),
+      hasAssertsModifier: this.hasAssertsModifier
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const name = obj.name;
+    const type = obj.type ? _schemaRegistry().SchemaRegistry.fromObject(obj.type) : undefined;
+    const hasAssertsModifier = obj.hasAssertsModifier;
+    return new TypePredicateSchema(location, name, type, hasAssertsModifier);
+  }
+}
+exports.TypePredicateSchema = TypePredicateSchema;
+
+//# sourceMappingURL=type-predicate.js.map