@fncts/schema 0.0.5 → 0.0.6

package/_cjs/AST.cjs

@@ -0,0 +1,1171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.anyKeyword = exports.VoidKeyword = exports.Validation = exports.UnknownKeyword = exports.UniqueSymbol = exports.Union = exports.UndefinedKeyword = exports.TypeLiteral = exports.Tuple = exports.Transform = exports.TemplateLiteralSpan = exports.TemplateLiteral = exports.SymbolKeyword = exports.StringKeyword = exports.Refinement = exports.PropertySignature = exports.ObjectKeyword = exports.NumberKeyword = exports.NeverKeyword = exports.Literal = exports.Lazy = exports.IndexSignature = exports.Enum = exports.Element = exports.Declaration = exports.BooleanKeyword = exports.BigIntKeyword = exports.AnyKeyword = exports.Annotated = exports.ASTTypeId = exports.AST = void 0;
+exports.appendElement = appendElement;
+exports.appendRestElement = appendRestElement;
+exports.booleanKeyword = exports.bigIntKeyword = void 0;
+exports.combineAnnotations = combineAnnotations;
+exports.concrete = concrete;
+exports.createElement = exports.createDeclaration = void 0;
+exports.createEnum = createEnum;
+exports.createIndexSignature = void 0;
+exports.createKey = createKey;
+exports.createPropertySignature = exports.createLiteral = exports.createLazy = void 0;
+exports.createRecord = createRecord;
+exports.createUniqueSymbol = exports.createUnion = exports.createTypeLiteral = exports.createTuple = exports.createTransform = exports.createTemplateLiteral = exports.createRefinement = void 0;
+exports.createValidation = createValidation;
+exports.getAnnotations = getAnnotations;
+exports.getCardinality = getCardinality;
+exports.getCompiler = getCompiler;
+exports.getFrom = void 0;
+exports.getParameter = getParameter;
+exports.getTo = exports.getPropertySignatures = void 0;
+exports.getWeight = getWeight;
+exports.isBigIntKeyword = isBigIntKeyword;
+exports.isBooleanKeyword = isBooleanKeyword;
+exports.isDeclaration = isDeclaration;
+exports.isLazy = isLazy;
+exports.isNumberKeyword = exports.isLiteral = void 0;
+exports.isRefinement = isRefinement;
+exports.isSymbolKeyword = exports.isStringKeyword = void 0;
+exports.isTypeLiteral = isTypeLiteral;
+exports.isUnion = isUnion;
+exports.isUniqueSymbol = void 0;
+exports.keyof = keyof;
+exports.objectKeyword = exports.numberKeyword = exports.neverKeyword = exports.keysOf = void 0;
+exports.omit = omit;
+exports.partial = void 0;
+exports.pick = pick;
+exports.reverse = void 0;
+exports.setAnnotation = setAnnotation;
+exports.voidKeyword = exports.unknownKeyword = exports.undefinedKeyword = exports.symbolKeyword = exports.stringKeyword = void 0;
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/schema/ASTAnnotation"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/api"));
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/number/instances"));
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Ord/api/contramap"));
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/internal"));
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/api"));
+var _Showable = /*#__PURE__*/require("@fncts/base/data/Showable");
+var _utils = /*#__PURE__*/require("@fncts/schema/utils");
+var _ASTAnnotationMap = /*#__PURE__*/require("./ASTAnnotationMap.cjs");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _a;
+const createDeclaration = createDeclaration_1;
+exports.createDeclaration = createDeclaration;
+const createLiteral = createLiteral_1;
+exports.createLiteral = createLiteral;
+const isLiteral = isLiteral_1;
+exports.isLiteral = isLiteral;
+const createUniqueSymbol = createUniqueSymbol_1;
+exports.createUniqueSymbol = createUniqueSymbol;
+const isUniqueSymbol = isUniqueSymbol_1;
+exports.isUniqueSymbol = isUniqueSymbol;
+const isStringKeyword = isStringKeyword_1;
+exports.isStringKeyword = isStringKeyword;
+const isNumberKeyword = isNumberKeyword_1;
+exports.isNumberKeyword = isNumberKeyword;
+const isSymbolKeyword = isSymbolKeyword_1;
+exports.isSymbolKeyword = isSymbolKeyword;
+const createTemplateLiteral = createTemplateLiteral_1;
+exports.createTemplateLiteral = createTemplateLiteral;
+const createElement = createElement_1;
+exports.createElement = createElement;
+const createTuple = createTuple_1;
+exports.createTuple = createTuple;
+const createPropertySignature = createPropertySignature_1;
+exports.createPropertySignature = createPropertySignature;
+const createIndexSignature = createIndexSignature_1;
+exports.createIndexSignature = createIndexSignature;
+const createTypeLiteral = createTypeLiteral_1;
+exports.createTypeLiteral = createTypeLiteral;
+const createUnion = createUnion_1;
+exports.createUnion = createUnion;
+const createLazy = createLazy_1;
+exports.createLazy = createLazy;
+const createRefinement = createRefinement_1;
+exports.createRefinement = createRefinement;
+const createTransform = createTransform_1;
+exports.createTransform = createTransform;
+const getPropertySignatures = getPropertySignatures_1;
+exports.getPropertySignatures = getPropertySignatures;
+const keysOf = keysOf_1;
+exports.keysOf = keysOf;
+const partial = partial_1;
+exports.partial = partial;
+const getFrom = getFrom_1;
+exports.getFrom = getFrom;
+const getTo = getTo_1;
+exports.getTo = getTo;
+const reverse = reverse_1;
+exports.reverse = reverse;
+const ASTTypeId = /*#__PURE__*/Symbol.for("fncts.schema.AST");
+exports.ASTTypeId = ASTTypeId;
+class Annotated {
+  constructor() {
+    this.annotations = _ASTAnnotationMap.ASTAnnotationMap.empty;
+  }
+}
+/**
+ * @tsplus type fncts.schema.AST
+ * @tsplus companion fncts.schema.ASTOps
+ */
+exports.Annotated = Annotated;
+class AST extends Annotated {
+  constructor() {
+    super(...arguments);
+    this[_a] = ASTTypeId;
+  }
+}
+exports.AST = AST;
+_a = ASTTypeId;
+/**
+ * @tsplus static fncts.schema.ASTOps concrete
+ * @tsplus macro remove
+ */
+function concrete(_) {
+  //
+}
+function getAnnotations(key) {
+  return self => {
+    return self.annotations.get(key);
+  };
+}
+/*
+ * Declaration
+ */
+class Declaration extends AST {
+  constructor(typeParameters, type, decode, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.typeParameters = typeParameters;
+    this.type = type;
+    this.decode = decode;
+    this.annotations = annotations;
+    this._tag = 0 /* ASTTag.Declaration */;
+  }
+
+  clone(newProperties) {
+    return new Declaration(newProperties.typeParameters ?? this.typeParameters, newProperties.type ?? this.type, newProperties.decode ?? this.decode, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createDeclaration
+ */
+exports.Declaration = Declaration;
+function createDeclaration_1(typeParameters, type, decode, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  return new Declaration(typeParameters, type, decode, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isDeclaration
+ */
+function isDeclaration(self) {
+  void 0;
+  return self._tag === 0 /* ASTTag.Declaration */;
+}
+
+class Literal extends AST {
+  constructor(literal, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.literal = literal;
+    this.annotations = annotations;
+    this._tag = 1 /* ASTTag.Literal */;
+  }
+
+  clone(newProperties) {
+    return new Literal(newProperties.literal ?? this.literal, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createLiteral
+ */
+exports.Literal = Literal;
+function createLiteral_1(literal, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  return new Literal(literal, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isLiteral
+ */
+function isLiteral_1(self) {
+  void 0;
+  return self._tag === 1 /* ASTTag.Literal */;
+}
+/*
+ * UniqueSymbol
+ */
+class UniqueSymbol extends AST {
+  constructor(symbol, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.symbol = symbol;
+    this.annotations = annotations;
+    this._tag = 2 /* ASTTag.UniqueSymbol */;
+  }
+
+  clone(newProperties) {
+    return new UniqueSymbol(newProperties.symbol ?? this.symbol, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createUniqueSymbol
+ */
+exports.UniqueSymbol = UniqueSymbol;
+function createUniqueSymbol_1(symbol, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  return new UniqueSymbol(symbol, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isUniqueSymbol
+ */
+function isUniqueSymbol_1(self) {
+  void 0;
+  return self._tag === 2 /* ASTTag.UniqueSymbol */;
+}
+/*
+ * UndefinedKeyword
+ */
+class UndefinedKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 3 /* ASTTag.UndefinedKeyword */;
+  }
+
+  clone(newProperties) {
+    return new UndefinedKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps undefinedKeyword
+ */
+exports.UndefinedKeyword = UndefinedKeyword;
+const undefinedKeyword_1 = /*#__PURE__*/new UndefinedKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "undefined"));
+const undefinedKeyword = undefinedKeyword_1;
+/*
+ * VoidKeyword
+ */
+exports.undefinedKeyword = undefinedKeyword;
+class VoidKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 4 /* ASTTag.VoidKeyword */;
+  }
+
+  clone(newProperties) {
+    return new VoidKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps voidKeyword
+ */
+exports.VoidKeyword = VoidKeyword;
+const voidKeyword = /*#__PURE__*/new VoidKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "void"));
+/*
+ * NeverKeyword
+ */
+exports.voidKeyword = voidKeyword;
+class NeverKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 5 /* ASTTag.NeverKeyword */;
+  }
+
+  clone(newProperties) {
+    return new NeverKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps neverKeyword
+ */
+exports.NeverKeyword = NeverKeyword;
+const neverKeyword_1 = /*#__PURE__*/new NeverKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "never"));
+const neverKeyword = neverKeyword_1;
+/*
+ * UnknownKeyword
+ */
+exports.neverKeyword = neverKeyword;
+class UnknownKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 6 /* ASTTag.UnknownKeyword */;
+  }
+
+  clone(newProperties) {
+    return new UnknownKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps unknownKeyword
+ */
+exports.UnknownKeyword = UnknownKeyword;
+const unknownKeyword = /*#__PURE__*/new UnknownKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "unknown"));
+/*
+ * AnyKeyword
+ */
+exports.unknownKeyword = unknownKeyword;
+class AnyKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 7 /* ASTTag.AnyKeyword */;
+  }
+
+  clone(newProperties) {
+    return new AnyKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps anyKeyword
+ */
+exports.AnyKeyword = AnyKeyword;
+const anyKeyword = /*#__PURE__*/new AnyKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "any"));
+/*
+ * StringKeyword
+ */
+exports.anyKeyword = anyKeyword;
+class StringKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 8 /* ASTTag.StringKeyword */;
+  }
+
+  clone(newProperties) {
+    return new StringKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps stringKeyword
+ */
+exports.StringKeyword = StringKeyword;
+const stringKeyword_1 = /*#__PURE__*/new StringKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "string"));
+const stringKeyword = stringKeyword_1;
+/**
+ * @tsplus fluent fncts.schema.AST isStringKeyword
+ */
+exports.stringKeyword = stringKeyword;
+function isStringKeyword_1(self) {
+  void 0;
+  return self._tag === 8 /* ASTTag.StringKeyword */;
+}
+/*
+ * NumberKeyword
+ */
+class NumberKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 9 /* ASTTag.NumberKeyword */;
+  }
+
+  clone(newProperties) {
+    return new NumberKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps numberKeyword
+ */
+exports.NumberKeyword = NumberKeyword;
+const numberKeyword_1 = /*#__PURE__*/new NumberKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "number"));
+const numberKeyword = numberKeyword_1;
+/**
+ * @tsplus fluent fncts.schema.AST isNumberKeyword
+ */
+exports.numberKeyword = numberKeyword;
+function isNumberKeyword_1(self) {
+  void 0;
+  return self._tag === 9 /* ASTTag.NumberKeyword */;
+}
+/*
+ * BooleanKeyword
+ */
+class BooleanKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 10 /* ASTTag.BooleanKeyword */;
+  }
+
+  clone(newProperties) {
+    return new BooleanKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps booleanKeyword
+ */
+exports.BooleanKeyword = BooleanKeyword;
+const booleanKeyword = /*#__PURE__*/new BooleanKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "boolean"));
+/**
+ * @tsplus fluent fncts.schema.AST isBooleanKeyword
+ */
+exports.booleanKeyword = booleanKeyword;
+function isBooleanKeyword(self) {
+  void 0;
+  return self._tag === 10 /* ASTTag.BooleanKeyword */;
+}
+/*
+ * BigIntKeyword
+ */
+class BigIntKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 11 /* ASTTag.BigIntKeyword */;
+  }
+
+  clone(newProperties) {
+    return new BigIntKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps bigIntKeyword
+ */
+exports.BigIntKeyword = BigIntKeyword;
+const bigIntKeyword = /*#__PURE__*/new BigIntKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "bigint"));
+/**
+ * @tsplus fluent fncts.schema.AST isBigIntKeyword
+ */
+exports.bigIntKeyword = bigIntKeyword;
+function isBigIntKeyword(self) {
+  void 0;
+  return self._tag === 11 /* ASTTag.BigIntKeyword */;
+}
+/*
+ * SymbolKeyword
+ */
+class SymbolKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 12 /* ASTTag.SymbolKeyword */;
+  }
+
+  clone(newProperties) {
+    return new SymbolKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps symbolKeyword
+ */
+exports.SymbolKeyword = SymbolKeyword;
+const symbolKeyword_1 = /*#__PURE__*/new SymbolKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "symbol"));
+const symbolKeyword = symbolKeyword_1;
+/**
+ * @tsplus fluent fncts.schema.AST isSymbolKeyword
+ */
+exports.symbolKeyword = symbolKeyword;
+function isSymbolKeyword_1(self) {
+  void 0;
+  return self._tag === 12 /* ASTTag.SymbolKeyword */;
+}
+/*
+ * ObjectKeyword
+ */
+class ObjectKeyword extends AST {
+  constructor(annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 13 /* ASTTag.ObjectKeyword */;
+  }
+
+  clone(newProperties) {
+    return new ObjectKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps objectKeyword
+ */
+exports.ObjectKeyword = ObjectKeyword;
+const objectKeyword = /*#__PURE__*/new ObjectKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "object"));
+/*
+ * Enum
+ */
+exports.objectKeyword = objectKeyword;
+class Enum extends AST {
+  constructor(enums, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.enums = enums;
+    this.annotations = annotations;
+    this._tag = 14 /* ASTTag.Enum */;
+  }
+
+  clone(newProperties) {
+    return new Enum(newProperties.enums ?? this.enums, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createEnum
+ */
+exports.Enum = Enum;
+function createEnum(enums, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  return new Enum(enums, annotations);
+}
+class TemplateLiteralSpan {
+  constructor(type, literal) {
+    this.type = type;
+    this.literal = literal;
+  }
+}
+/*
+ * TemplateLiteral
+ */
+exports.TemplateLiteralSpan = TemplateLiteralSpan;
+class TemplateLiteral extends AST {
+  constructor(head, spans, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.head = head;
+    this.spans = spans;
+    this.annotations = annotations;
+    this._tag = 15 /* ASTTag.TemplateLiteral */;
+  }
+
+  clone(newProperties) {
+    return createTemplateLiteral_1(newProperties.head ?? this.head, newProperties.spans ?? this.spans, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTemplateLiteral
+ */
+exports.TemplateLiteral = TemplateLiteral;
+function createTemplateLiteral_1(head, spans, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  if (tsplus_module_2.isNonEmpty(spans)) {
+    return new TemplateLiteral(head, spans, annotations);
+  } else {
+    return createLiteral_1(head, annotations);
+  }
+}
+/*
+ * Element
+ */
+class Element {
+  constructor(type, isOptional) {
+    this.type = type;
+    this.isOptional = isOptional;
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createElement
+ */
+exports.Element = Element;
+function createElement_1(type, isOptional) {
+  return new Element(type, isOptional);
+}
+/*
+ * Tuple
+ */
+class Tuple extends AST {
+  constructor(elements, rest, isReadonly, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.elements = elements;
+    this.rest = rest;
+    this.isReadonly = isReadonly;
+    this.annotations = annotations;
+    this._tag = 16 /* ASTTag.Tuple */;
+  }
+
+  clone(newProperties) {
+    return new Tuple(newProperties.elements ?? this.elements, newProperties.rest ?? this.rest, newProperties.isReadonly ?? this.isReadonly, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTuple
+ */
+exports.Tuple = Tuple;
+function createTuple_1(elements, rest, isReadonly, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  return new Tuple(elements, rest, isReadonly, annotations);
+}
+/*
+ * PropertySignature
+ */
+class PropertySignature extends AST {
+  constructor(name, type, isOptional, isReadonly, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.name = name;
+    this.type = type;
+    this.isOptional = isOptional;
+    this.isReadonly = isReadonly;
+    this.annotations = annotations;
+  }
+  clone(newProperties) {
+    return new PropertySignature(newProperties.name ?? this.name, newProperties.type ?? this.type, newProperties.isOptional ?? this.isOptional, newProperties.isReadonly ?? this.isReadonly, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createPropertySignature
+ */
+exports.PropertySignature = PropertySignature;
+function createPropertySignature_1(name, type, isOptional, isReadonly, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  return new PropertySignature(name, type, isOptional, isReadonly, annotations);
+}
+/*
+ * IndexSignature
+ */
+class IndexSignature {
+  constructor(parameter, type, isReadonly) {
+    this.parameter = parameter;
+    this.type = type;
+    this.isReadonly = isReadonly;
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createIndexSignature
+ */
+exports.IndexSignature = IndexSignature;
+function createIndexSignature_1(parameter, type, isReadonly) {
+  return new IndexSignature(parameter, type, isReadonly);
+}
+/*
+ * TypeLiteral
+ */
+class TypeLiteral extends AST {
+  constructor(propertySignatures, indexSignatures, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 17 /* ASTTag.TypeLiteral */;
+    this.propertySignatures = sortByAscendingCardinality(propertySignatures);
+    this.indexSignatures = sortByAscendingCardinality(indexSignatures);
+  }
+  clone(newProperties) {
+    return new TypeLiteral(newProperties.propertySignatures ?? this.propertySignatures, newProperties.indexSignatures ?? this.indexSignatures, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps isTypeLiteral
+ * @tsplus fluent fncts.schema.AST isTypeLiteral
+ */
+exports.TypeLiteral = TypeLiteral;
+function isTypeLiteral(self) {
+  void 0;
+  return self._tag === 17 /* ASTTag.TypeLiteral */;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTypeLiteral
+ */
+function createTypeLiteral_1(propertySignatures, indexSignatures, annotations) {
+  return new TypeLiteral(propertySignatures, indexSignatures, annotations);
+}
+/*
+ * Union
+ */
+class Union extends AST {
+  constructor(types, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.types = types;
+    this.annotations = annotations;
+    this._tag = 18 /* ASTTag.Union */;
+  }
+
+  clone(newProperties) {
+    return createUnion_1(newProperties.types ?? this.types, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus fluent fncts.schema.AST isUnion
+ */
+exports.Union = Union;
+function isUnion(self) {
+  void 0;
+  return self._tag === 18 /* ASTTag.Union */;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createUnion
+ */
+function createUnion_1(candidates, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  const types = unify(candidates);
+  switch (types.length) {
+    case 0:
+      return neverKeyword_1;
+    case 1:
+      return tsplus_module_2.unsafeGet(0)(types);
+    default:
+      return new Union(sortByDescendingWeight(types), annotations);
+  }
+}
+/*
+ * Lazy
+ */
+class Lazy extends AST {
+  constructor(getAST, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.getAST = getAST;
+    this.annotations = annotations;
+    this._tag = 19 /* ASTTag.Lazy */;
+  }
+
+  clone(newProperties) {
+    return new Lazy(newProperties.getAST ?? this.getAST, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createLazy
+ */
+exports.Lazy = Lazy;
+function createLazy_1(getAST, annotations) {
+  return new Lazy(getAST, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isLazy
+ */
+function isLazy(self) {
+  void 0;
+  return self._tag === 19 /* ASTTag.Lazy */;
+}
+/*
+ * Refinement
+ */
+class Refinement extends AST {
+  constructor(from, decode, isReversed, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.from = from;
+    this.decode = decode;
+    this.isReversed = isReversed;
+    this.annotations = annotations;
+    this._tag = 20 /* ASTTag.Refinement */;
+  }
+
+  clone(newProperties) {
+    return new Refinement(newProperties.from ?? this.from, newProperties.decode ?? this.decode, newProperties.isReversed ?? this.isReversed, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createRefinement
+ */
+exports.Refinement = Refinement;
+function createRefinement_1(from, decode, isReversed, annotations) {
+  return new Refinement(from, decode, isReversed, annotations);
+}
+function isRefinement(self) {
+  void 0;
+  return self._tag === 20 /* ASTTag.Refinement */;
+}
+/*
+ * Transform
+ */
+class Transform extends AST {
+  constructor(from, to, decode, encode, isReversed, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.decode = decode;
+    this.encode = encode;
+    this.isReversed = isReversed;
+    this.annotations = annotations;
+    this._tag = 21 /* ASTTag.Transform */;
+  }
+
+  clone(newProperties) {
+    return new Transform(newProperties.from ?? this.from, newProperties.to ?? this.to, newProperties.decode ?? this.decode, newProperties.encode ?? this.encode, newProperties.isReversed ?? this.isReversed, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTransform
+ */
+exports.Transform = Transform;
+function createTransform_1(from, to, decode, encode, isReversed, annotations) {
+  return new Transform(from, getTo_1(to), decode, encode, isReversed, annotations);
+}
+/*
+ * Validation
+ */
+class Validation extends AST {
+  constructor(from, validation, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+    super();
+    this.from = from;
+    this.validation = validation;
+    this.annotations = annotations;
+    this._tag = 22 /* ASTTag.Validation */;
+  }
+
+  clone(newProperties) {
+    return new Validation(newProperties.from ?? this.from, newProperties.validation ?? this.validation, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createValidation
+ */
+exports.Validation = Validation;
+function createValidation(from, validation, annotations) {
+  return new Validation(from, validation, annotations);
+}
+/**
+ * @tsplus tailRec
+ */
+function getCardinality(ast) {
+  var ast_1 = ast;
+  var ast_2 = ast;
+  while (1) {
+    void 0;
+    switch (ast_1._tag) {
+      case 0 /* ASTTag.Declaration */:
+        ast_2 = ast_1.type;
+        ast_1 = ast_2;
+        continue;
+      case 5 /* ASTTag.NeverKeyword */:
+        return 0;
+      case 1 /* ASTTag.Literal */:
+      case 3 /* ASTTag.UndefinedKeyword */:
+      case 4 /* ASTTag.VoidKeyword */:
+      case 2 /* ASTTag.UniqueSymbol */:
+        return 1;
+      case 10 /* ASTTag.BooleanKeyword */:
+        return 2;
+      case 8 /* ASTTag.StringKeyword */:
+      case 9 /* ASTTag.NumberKeyword */:
+      case 11 /* ASTTag.BigIntKeyword */:
+      case 12 /* ASTTag.SymbolKeyword */:
+        return 3;
+      case 13 /* ASTTag.ObjectKeyword */:
+        return 4;
+      case 6 /* ASTTag.UnknownKeyword */:
+      case 7 /* ASTTag.AnyKeyword */:
+        return 6;
+      case 20 /* ASTTag.Refinement */:
+        ast_2 = ast_1.from;
+        ast_1 = ast_2;
+        continue;
+      case 21 /* ASTTag.Transform */:
+        ast_2 = ast_1.to;
+        ast_1 = ast_2;
+        continue;
+      default:
+        return 5;
+    }
+  }
+}
+function sortByAscendingCardinality(types) {
+  return tsplus_module_2.sort(tsplus_module_4.contramap(({
+    type
+  }) => getCardinality(type))(tsplus_module_3.Ord))(types);
+}
+function getWeight(ast) {
+  void 0;
+  switch (ast._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return getWeight(ast.type);
+    case 16 /* ASTTag.Tuple */:
+      return ast.elements.length + (tsplus_module_5.isJust(ast.rest) ? ast.rest.value.length : 0);
+    case 17 /* ASTTag.TypeLiteral */:
+      return ast.propertySignatures.length + ast.indexSignatures.length;
+    case 18 /* ASTTag.Union */:
+      return tsplus_module_2.foldLeft(0, (n, member) => n + getWeight(member))(ast.types);
+    case 19 /* ASTTag.Lazy */:
+      return 10;
+    case 20 /* ASTTag.Refinement */:
+      return getWeight(ast.from);
+    case 21 /* ASTTag.Transform */:
+      return getWeight(ast.to);
+    default:
+      return 0;
+  }
+}
+function sortByDescendingWeight(types) {
+  return tsplus_module_2.sort(tsplus_module_4.contramap(getWeight)(tsplus_module_3.Ord))(types);
+}
+function unify(candidates) {
+  let out = tsplus_module_2.flatMap(ast => {
+    void 0;
+    switch (ast._tag) {
+      case 5 /* ASTTag.NeverKeyword */:
+        return tsplus_module_2.empty();
+      case 18 /* ASTTag.Union */:
+        return ast.types;
+      default:
+        return tsplus_module_2.vector(ast);
+    }
+  })(candidates);
+  if (tsplus_module_2.some(isStringKeyword_1)(out)) {
+    out = tsplus_module_2.filter(m => !(isLiteral_1(m) && typeof m.literal === "string"))(out);
+  }
+  if (tsplus_module_2.some(isNumberKeyword_1)(out)) {
+    out = tsplus_module_2.filter(m => !(isLiteral_1(m) && typeof m.literal === "number"))(out);
+  }
+  if (tsplus_module_2.some(isSymbolKeyword_1)(out)) {
+    out = tsplus_module_2.filter(m => !isUniqueSymbol_1(m))(out);
+  }
+  return out;
+}
+/**
+ * @tsplus pipeable fncts.schema.AST combineAnnotations
+ */
+function combineAnnotations(annotations) {
+  return self => {
+    return self.clone({
+      annotations: self.annotations.combine(annotations)
+    });
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST setAnnotation
+ */
+function setAnnotation(annotation, value) {
+  return self => {
+    return self.clone({
+      annotations: self.annotations.annotate(annotation, value)
+    });
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST appendRestElement
+ */
+function appendRestElement(restElement) {
+  return self => {
+    if (tsplus_module_5.isJust(self.rest)) {
+      throw new Error("A rest element cannot follow another rest element. ts(1265)");
+    }
+    return createTuple_1(self.elements, tsplus_module_6.just(tsplus_module_2.vector(restElement)), self.isReadonly, self.annotations);
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST appendElement
+ */
+function appendElement(element) {
+  return self => {
+    if (tsplus_module_2.some(e => e.isOptional)(self.elements) && !element.isOptional) {
+      throw new Error("A required element cannot follow an optional element. ts(1257)");
+    }
+    return tsplus_module_7.match(() => createTuple_1(tsplus_module_2.append(element)(self.elements), tsplus_module_6.nothing(), self.isReadonly, self.annotations), rest => {
+      if (element.isOptional) {
+        throw new Error("A required element cannot follow an optional element. ts(1257)");
+      }
+      return createTuple_1(self.elements, tsplus_module_6.just(tsplus_module_2.append(element.type)(rest)), self.isReadonly, self.annotations);
+    })(self.rest);
+  };
+}
+function getParameter(x) {
+  return isRefinement(x) ? getParameter(x.from) : x;
+}
+/**
+ * @tsplus getter fncts.schema.AST getPropertySignatures
+ */
+function getPropertySignatures_1(self) {
+  void 0;
+  switch (self._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return getPropertySignatures_1(self.type);
+    case 16 /* ASTTag.Tuple */:
+      return tsplus_module_2.mapWithIndex((i, element) => createPropertySignature_1(i, element.type, element.isOptional, self.isReadonly))(self.elements);
+    case 18 /* ASTTag.Union */:
+      {
+        const propertySignatures = tsplus_module_2.map(getPropertySignatures_1)(self.types);
+        return tsplus_module_2.filterMap(({
+          name
+        }) => {
+          if (tsplus_module_2.every(ps => tsplus_module_2.some(p => p.name === name)(ps))(propertySignatures)) {
+            const members = tsplus_module_2.flatMap(ps => tsplus_module_2.filter(p => p.name === name)(ps))(propertySignatures);
+            return tsplus_module_6.just(createPropertySignature_1(name, createUnion_1(tsplus_module_2.map(p => p.type)(members)), tsplus_module_2.some(p => p.isOptional)(members), tsplus_module_2.some(p => p.isReadonly)(members)));
+          }
+          return tsplus_module_6.nothing();
+        })(tsplus_module_2.unsafeGet(0)(propertySignatures));
+      }
+    case 19 /* ASTTag.Lazy */:
+      return getPropertySignatures_1(self.getAST());
+    case 20 /* ASTTag.Refinement */:
+      return getPropertySignatures_1(self.from);
+    case 21 /* ASTTag.Transform */:
+      return getPropertySignatures_1(self.to);
+    default:
+      return tsplus_module_2.empty();
+  }
+}
+/**
+ * @tsplus getter fncts.schema.AST keysof
+ */
+function keysOf_1(ast) {
+  void 0;
+  switch (ast._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return keysOf_1(ast.type);
+    case 5 /* ASTTag.NeverKeyword */:
+    case 7 /* ASTTag.AnyKeyword */:
+      return tsplus_module_2.vector(stringKeyword_1, numberKeyword_1, symbolKeyword_1);
+    case 8 /* ASTTag.StringKeyword */:
+      return tsplus_module_2.vector(createLiteral_1("length"));
+    case 17 /* ASTTag.TypeLiteral */:
+      return tsplus_module_2.concat(tsplus_module_2.map(is => getParameter(is.parameter))(ast.indexSignatures))(tsplus_module_2.map(p => typeof p.name === "symbol" ? createUniqueSymbol_1(p.name) : createLiteral_1(p.name))(ast.propertySignatures));
+    case 18 /* ASTTag.Union */:
+      return tsplus_module_2.map(p => typeof p.name === "symbol" ? createUniqueSymbol_1(p.name) : createLiteral_1(p.name))(getPropertySignatures_1(ast));
+    case 19 /* ASTTag.Lazy */:
+      return keysOf_1(ast.getAST());
+    case 20 /* ASTTag.Refinement */:
+      return keysOf_1(ast.from);
+    case 21 /* ASTTag.Transform */:
+      return keysOf_1(ast.to);
+    default:
+      return tsplus_module_2.empty();
+  }
+}
+/**
+ * @tsplus getter fncts.schema.AST keyof
+ */
+function keyof(self) {
+  return createUnion_1(keysOf_1(self));
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createRecord
+ */
+function createRecord(key, value, isReadonly) {
+  const propertySignatures = tsplus_module_2.emptyPushable();
+  const indexSignatures = tsplus_module_2.emptyPushable();
+  function go(key) {
+    void 0;
+    switch (key._tag) {
+      case 0 /* ASTTag.Declaration */:
+        go(key.type);
+        break;
+      case 5 /* ASTTag.NeverKeyword */:
+        break;
+      case 8 /* ASTTag.StringKeyword */:
+      case 12 /* ASTTag.SymbolKeyword */:
+      case 15 /* ASTTag.TemplateLiteral */:
+      case 20 /* ASTTag.Refinement */:
+        tsplus_module_8.push(createIndexSignature_1(key, value, isReadonly))(indexSignatures);
+        break;
+      case 1 /* ASTTag.Literal */:
+        if (typeof key.literal === "string" || typeof key.literal === "number") {
+          tsplus_module_8.push(createPropertySignature_1(key.literal, value, false, isReadonly))(propertySignatures);
+        }
+        break;
+      case 2 /* ASTTag.UniqueSymbol */:
+        tsplus_module_8.push(createPropertySignature_1(key.symbol, value, false, isReadonly))(propertySignatures);
+        break;
+      case 18 /* ASTTag.Union */:
+        tsplus_module_2.forEach(go)(key.types);
+        break;
+      default:
+        throw new Error(`createRecord: Unsupported key\n${(0, _Showable.show)(key)}`);
+    }
+  }
+  go(key);
+  return createTypeLiteral_1(propertySignatures, indexSignatures);
+}
+/**
+ * @tsplus pipeable fncts.schema.AST pick
+ */
+function pick(keys) {
+  return self => {
+    return createTypeLiteral_1(tsplus_module_2.filter(ps => tsplus_module_2.includes(ps.name)(keys))(getPropertySignatures_1(self)), tsplus_module_2.empty());
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST omit
+ */
+function omit(keys) {
+  return self => {
+    return createTypeLiteral_1(tsplus_module_2.filter(ps => !tsplus_module_2.includes(ps.name)(keys))(getPropertySignatures_1(self)), tsplus_module_2.empty());
+  };
+}
+/**
+ * @tsplus getter fncts.schema.AST partial
+ */
+function partial_1(self) {
+  void 0;
+  switch (self._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return partial_1(self.type);
+    case 16 /* ASTTag.Tuple */:
+      return createTuple_1(tsplus_module_2.map(e => createElement_1(e.type, true))(self.elements), tsplus_module_9.map(rest => tsplus_module_2.vector(createUnion_1(tsplus_module_2.append(undefinedKeyword_1)(rest))))(self.rest), self.isReadonly);
+    case 17 /* ASTTag.TypeLiteral */:
+      return createTypeLiteral_1(tsplus_module_2.map(f => createPropertySignature_1(f.name, f.type, true, f.isReadonly, f.annotations))(self.propertySignatures), self.indexSignatures);
+    case 18 /* ASTTag.Union */:
+      return createUnion_1(tsplus_module_2.map(partial_1)(self.types));
+    case 19 /* ASTTag.Lazy */:
+      return createLazy_1(() => partial_1(self.getAST()));
+    case 20 /* ASTTag.Refinement */:
+      return partial_1(self.from);
+    case 21 /* ASTTag.Transform */:
+      return partial_1(self.to);
+    default:
+      return self;
+  }
+}
+/**
+ * @tsplus static fncts.schema.AST createKey
+ */
+function createKey(key) {
+  return typeof key === "symbol" ? createUniqueSymbol_1(key) : createLiteral_1(key);
+}
+/**
+ * @tsplus getter fncts.schema.AST getFrom
+ */
+function getFrom_1(ast) {
+  void 0;
+  switch (ast._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return createDeclaration_1(tsplus_module_2.map(getFrom_1)(ast.typeParameters), ast.type, ast.decode, ast.annotations);
+    case 16 /* ASTTag.Tuple */:
+      return createTuple_1(tsplus_module_2.map(element => createElement_1(getFrom_1(element.type), element.isOptional))(ast.elements), tsplus_module_9.map(restElement => tsplus_module_2.map(getFrom_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
+    case 17 /* ASTTag.TypeLiteral */:
+      return createTypeLiteral_1(tsplus_module_2.map(ps => createPropertySignature_1(ps.name, getFrom_1(ps.type), ps.isOptional, ps.isReadonly, ps.annotations))(ast.propertySignatures), tsplus_module_2.map(is => createIndexSignature_1(is.parameter, getFrom_1(is.type), is.isReadonly))(ast.indexSignatures), ast.annotations);
+    case 18 /* ASTTag.Union */:
+      return createUnion_1(tsplus_module_2.map(getFrom_1)(ast.types), ast.annotations);
+    case 19 /* ASTTag.Lazy */:
+      return createLazy_1(() => getFrom_1(ast.getAST()), ast.annotations);
+    case 20 /* ASTTag.Refinement */:
+    case 21 /* ASTTag.Transform */:
+      return getFrom_1(ast.from);
+  }
+  return ast;
+}
+/**
+ * @tsplus getter fncts.schema.AST getTo
+ */
+function getTo_1(ast) {
+  void 0;
+  switch (ast._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return createDeclaration_1(tsplus_module_2.map(getTo_1)(ast.typeParameters), ast.type, ast.decode, ast.annotations);
+    case 16 /* ASTTag.Tuple */:
+      return createTuple_1(tsplus_module_2.map(element => createElement_1(getTo_1(element.type), element.isOptional))(ast.elements), tsplus_module_9.map(restElement => tsplus_module_2.map(getTo_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
+    case 17 /* ASTTag.TypeLiteral */:
+      return createTypeLiteral_1(tsplus_module_2.map(ps => createPropertySignature_1(ps.name, getTo_1(ps.type), ps.isOptional, ps.isReadonly, ps.annotations))(ast.propertySignatures), tsplus_module_2.map(is => createIndexSignature_1(is.parameter, getTo_1(is.type), is.isReadonly))(ast.indexSignatures), ast.annotations);
+    case 18 /* ASTTag.Union */:
+      return createUnion_1(tsplus_module_2.map(getTo_1)(ast.types), ast.annotations);
+    case 19 /* ASTTag.Lazy */:
+      return createLazy_1(() => getTo_1(ast.getAST()), ast.annotations);
+    case 20 /* ASTTag.Refinement */:
+      return createRefinement_1(getTo_1(ast.from), ast.decode, false, ast.annotations);
+    case 21 /* ASTTag.Transform */:
+      return getTo_1(ast.to);
+  }
+  return ast;
+}
+/**
+ * @tsplus getter fncts.schema.AST reverse
+ */
+function reverse_1(ast) {
+  void 0;
+  switch (ast._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return createDeclaration_1(tsplus_module_2.map(reverse_1)(ast.typeParameters), ast.type, ast.decode, ast.annotations);
+    case 16 /* ASTTag.Tuple */:
+      return createTuple_1(tsplus_module_2.map(element => createElement_1(reverse_1(element.type), element.isOptional))(ast.elements), tsplus_module_9.map(restElement => tsplus_module_2.map(reverse_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
+    case 17 /* ASTTag.TypeLiteral */:
+      return createTypeLiteral_1(tsplus_module_2.map(ps => createPropertySignature_1(ps.name, reverse_1(ps.type), ps.isOptional, ps.isReadonly, ps.annotations))(ast.propertySignatures), tsplus_module_2.map(is => createIndexSignature_1(is.parameter, reverse_1(is.type), is.isReadonly))(ast.indexSignatures), ast.annotations);
+    case 18 /* ASTTag.Union */:
+      return createUnion_1(tsplus_module_2.map(reverse_1)(ast.types), ast.annotations);
+    case 19 /* ASTTag.Lazy */:
+      return createLazy_1(() => reverse_1(ast.getAST()), ast.annotations);
+    case 20 /* ASTTag.Refinement */:
+      return createRefinement_1(ast.from, ast.decode, !ast.isReversed, ast.annotations);
+    case 21 /* ASTTag.Transform */:
+      return createTransform_1(reverse_1(ast.from), ast.to, ast.decode, ast.encode, !ast.isReversed, ast.annotations);
+  }
+  return ast;
+}
+/**
+ * @tsplus static fncts.schema.AST getCompiler
+ */
+function getCompiler(match) {
+  const compile = (0, _utils.memoize)(ast => {
+    void 0;
+    return match[ast._tag](ast, compile);
+  });
+  return compile;
+}
+//# sourceMappingURL=AST.cjs.map