@player-tools/xlr-utils 0.0.2-next.0

package/README.md

@@ -0,0 +1,3 @@
+# @player-tools/xlr-utils
+
+Package for shared utilities for creating, reading, type checking, and testing XLR functionality. 

package/dist/index.cjs.js

@@ -0,0 +1,526 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+function extractDescription(text) {
+  if (!text) {
+    return {};
+  }
+  return { description: text };
+}
+function parentIsNonObjectPath(node) {
+  return node.parent && (ts__namespace.isArrayTypeNode(node.parent) || ts__namespace.isTupleTypeNode(node.parent) || ts__namespace.isOptionalTypeNode(node.parent) || ts__namespace.isRestTypeNode(node.parent) || ts__namespace.isUnionTypeNode(node.parent));
+}
+function recurseTypeChain(node, child) {
+  if (!node) {
+    return [];
+  }
+  if (ts__namespace.isArrayTypeNode(node) && node.parent && ts__namespace.isRestTypeNode(node.parent)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts__namespace.isRestTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts__namespace.isOptionalTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts__namespace.isUnionTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts__namespace.isParenthesizedTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts__namespace.isTypeLiteralNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts__namespace.isArrayTypeNode(node)) {
+    return ["[]", ...recurseTypeChain(node.parent, node)];
+  }
+  if (ts__namespace.isTupleTypeNode(node)) {
+    const pos = node.elements.indexOf(child);
+    return [
+      ...pos === -1 ? [] : [`${pos}`],
+      ...recurseTypeChain(node.parent, node)
+    ];
+  }
+  if (ts__namespace.isTypeAliasDeclaration(node) || ts__namespace.isInterfaceDeclaration(node) || ts__namespace.isPropertySignature(node)) {
+    return [node.name.getText(), ...recurseTypeChain(node.parent, node)];
+  }
+  if (parentIsNonObjectPath(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  return [];
+}
+function extractTitle(node) {
+  const typeNames = recurseTypeChain(node, void 0).reverse().join(".");
+  if (!typeNames.length) {
+    return {};
+  }
+  return { title: typeNames };
+}
+function stringifyDoc(docString) {
+  if (typeof docString === "undefined" || typeof docString === "string") {
+    return docString;
+  }
+  return docString.map(({ text }) => text).join(" ");
+}
+function extractTags(tags) {
+  const descriptions = [];
+  const examples = [];
+  const _default = [];
+  const see = [];
+  const extractSee = (tag) => {
+    var _a, _b, _c;
+    return `${tag.tagName ? `${(_a = tag.tagName) == null ? void 0 : _a.getText()} ` : ""}${(_c = (_b = stringifyDoc(tag.comment)) == null ? void 0 : _b.trim()) != null ? _c : ""}`;
+  };
+  tags.forEach((tag) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (!tag.comment) {
+      return;
+    }
+    if (tag.tagName.text === "example") {
+      examples.push((_b = (_a = stringifyDoc(tag.comment)) == null ? void 0 : _a.trim()) != null ? _b : "");
+    } else if (tag.tagName.text === "default") {
+      _default.push((_d = (_c = stringifyDoc(tag.comment)) == null ? void 0 : _c.trim()) != null ? _d : "");
+    } else if (tag.tagName.text === "see") {
+      see.push(extractSee(tag));
+    } else {
+      const text = (_f = (_e = stringifyDoc(tag.comment)) == null ? void 0 : _e.trim()) != null ? _f : "";
+      descriptions.push(`@${tag.tagName.text} ${text}`);
+    }
+  });
+  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, descriptions.length === 0 ? {} : { description: descriptions.join("\n") }), examples.length === 0 ? {} : { examples }), _default.length === 0 ? {} : { default: _default.join("\n") }), see.length === 0 ? {} : { see });
+}
+function join(t, separator = "\n") {
+  const unique = new Set(t).values();
+  return Array.from(unique).filter((s) => s !== void 0).join(separator).trim();
+}
+function mergeAnnotations(nodes) {
+  var _a;
+  const name = (_a = nodes.find((n) => n.name)) == null ? void 0 : _a.name;
+  const title = join(nodes.map((n) => n.title), ", ");
+  const description = join(nodes.map((n) => n.description));
+  const _default = join(nodes.map((n) => n.default));
+  const comment = join(nodes.map((n) => n.comment));
+  const examples = join(nodes.map((n) => Array.isArray(n.examples) ? join(n.examples) : n.examples));
+  const see = join(nodes.map((n) => Array.isArray(n.see) ? join(n.see) : n.see));
+  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, name ? { name } : {}), title ? { title } : {}), description ? { description } : {}), examples ? { examples } : {}), _default ? { default: _default } : {}), see ? { see } : {}), comment ? { comment } : {});
+}
+function decorateNode(node) {
+  var _a;
+  const { jsDoc } = node;
+  const titleAnnotation = extractTitle(node);
+  if (jsDoc && jsDoc.length) {
+    const first = jsDoc[0];
+    return mergeAnnotations([
+      extractDescription(stringifyDoc(first.comment)),
+      titleAnnotation,
+      extractTags((_a = first.tags) != null ? _a : [])
+    ]);
+  }
+  return titleAnnotation;
+}
+
+function isOptionalProperty(node) {
+  var _a;
+  return ((_a = node.questionToken) == null ? void 0 : _a.kind) === ts__default["default"].SyntaxKind.QuestionToken;
+}
+function isGenericInterfaceDeclaration(node) {
+  var _a;
+  const length = (_a = node.typeParameters) == null ? void 0 : _a.length;
+  return length ? length > 0 : false;
+}
+function isGenericTypeDeclaration(node) {
+  var _a;
+  const length = (_a = node.typeParameters) == null ? void 0 : _a.length;
+  return length ? length > 0 : false;
+}
+function isTypeReferenceGeneric(node, typeChecker) {
+  const symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && symbol.declarations) {
+    return symbol.declarations[0].kind === ts__default["default"].SyntaxKind.TypeParameter;
+  }
+  return false;
+}
+function isTopLevelNode(node) {
+  return node.kind === ts__default["default"].SyntaxKind.InterfaceDeclaration || node.kind === ts__default["default"].SyntaxKind.TypeAliasDeclaration;
+}
+function isGenericNodeType(nt) {
+  var _a;
+  return ((_a = nt.genericTokens) == null ? void 0 : _a.length) > 0;
+}
+function isGenericNamedType(nt) {
+  var _a;
+  return ((_a = nt.genericTokens) == null ? void 0 : _a.length) > 0;
+}
+function isPrimitiveTypeNode(node) {
+  return node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null" || node.type === "template" || node.type === "any" || node.type === "never" || node.type === "undefined" || node.type === "unknown";
+}
+function isNonNullable(a) {
+  return a !== null || a !== void 0;
+}
+
+function propertyToTuple(node) {
+  var _a, _b;
+  let key = (_a = node.children) == null ? void 0 : _a[0].value;
+  if (key.includes("-")) {
+    key = `'${key}'`;
+  }
+  return {
+    key,
+    value: (_b = node.children) == null ? void 0 : _b[1]
+  };
+}
+function makePropertyMap(node) {
+  var _a;
+  const m = new Map();
+  (_a = node.children) == null ? void 0 : _a.forEach((child) => {
+    const property = propertyToTuple(child);
+    m.set(property.key, property.value);
+  });
+  return m;
+}
+function isNode(obj) {
+  return typeof obj !== "string" || typeof obj !== "number" || typeof obj !== "boolean";
+}
+function resolveConditional(conditional) {
+  const { left, right } = conditional.check;
+  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
+    if (left.const && right.const) {
+      return left.const === right.const ? conditional.value.true : conditional.value.false;
+    }
+    if ((left.type === "any" || left.type === "unknown") && (right.type === "any" || right.type === "unknown")) {
+      return conditional.value.true;
+    }
+    if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
+      return conditional.value.true;
+    }
+    if (left.type === right.type) {
+      return conditional.value.true;
+    }
+    return conditional.value.false;
+  }
+  return conditional;
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function tsStripOptionalType(node) {
+  return ts__namespace.isOptionalTypeNode(node) ? node.type : node;
+}
+function isExportedDeclaration(node) {
+  var _a;
+  return !!((_a = node.modifiers) == null ? void 0 : _a.some((modifier) => modifier.kind === ts__namespace.SyntaxKind.ExportKeyword));
+}
+function isNodeExported(node) {
+  return (ts__namespace.getCombinedModifierFlags(node) & ts__namespace.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === ts__namespace.SyntaxKind.SourceFile;
+}
+function getReferencedType(node, typeChecker) {
+  var _a;
+  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && (symbol.flags & ts__namespace.SymbolFlags.Alias) === ts__namespace.SymbolFlags.Alias) {
+    symbol = typeChecker.getAliasedSymbol(symbol);
+  }
+  const varDecl = (_a = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a[0];
+  if (varDecl && (ts__namespace.isInterfaceDeclaration(varDecl) || ts__namespace.isTypeAliasDeclaration(varDecl))) {
+    return { declaration: varDecl, exported: isNodeExported(varDecl) };
+  }
+}
+function getStringLiteralsFromUnion(node) {
+  if (ts__namespace.isUnionTypeNode(node)) {
+    return new Set(node.types.map((type) => {
+      if (ts__namespace.isLiteralTypeNode(type) && ts__namespace.isStringLiteral(type.literal)) {
+        return type.literal.text;
+      }
+      return "";
+    }));
+  }
+  if (ts__namespace.isLiteralTypeNode(node) && ts__namespace.isStringLiteral(node.literal)) {
+    return new Set([node.literal.text]);
+  }
+  return new Set();
+}
+function buildTemplateRegex(node, typeChecker) {
+  let regex = node.head.text;
+  node.templateSpans.forEach((span) => {
+    var _a;
+    let type = span.type.kind;
+    if (ts__namespace.isTypeReferenceNode(span.type)) {
+      let symbol = typeChecker.getSymbolAtLocation(span.type.typeName);
+      if (symbol && (symbol.flags & ts__namespace.SymbolFlags.Alias) === ts__namespace.SymbolFlags.Alias) {
+        symbol = typeChecker.getAliasedSymbol(symbol);
+      }
+      type = ((_a = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a[0]).type.kind;
+    }
+    if (type === ts__namespace.SyntaxKind.StringKeyword) {
+      regex += ".*";
+    } else if (type === ts__namespace.SyntaxKind.NumberKeyword) {
+      regex += "[0-9]*";
+    } else if (type === ts__namespace.SyntaxKind.BooleanKeyword) {
+      regex += "true|false";
+    }
+    regex += span.literal.text;
+  });
+  return regex;
+}
+function fillInGenerics(xlrNode, generics) {
+  var _a;
+  let localGenerics;
+  if (generics) {
+    localGenerics = new Map(generics);
+  } else {
+    localGenerics = new Map();
+    if (isGenericNodeType(xlrNode)) {
+      (_a = xlrNode.genericTokens) == null ? void 0 : _a.forEach((token) => {
+        var _a2;
+        localGenerics.set(token.symbol, (_a2 = token.default) != null ? _a2 : token.constraints);
+      });
+    }
+  }
+  if (xlrNode.type === "ref") {
+    if (localGenerics.has(xlrNode.ref)) {
+      return __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, localGenerics.get(xlrNode.ref)), xlrNode.genericArguments ? {
+        genericArguments: xlrNode.genericArguments.map((ga) => fillInGenerics(ga, localGenerics))
+      } : {}), xlrNode.title ? { title: xlrNode.title } : {}), xlrNode.name ? { name: xlrNode.name } : {}), xlrNode.description ? { description: xlrNode.description } : {}), xlrNode.comment ? { comment: xlrNode.comment } : {});
+    }
+    return __spreadValues(__spreadValues({}, xlrNode), xlrNode.genericArguments ? {
+      genericArguments: xlrNode.genericArguments.map((ga) => fillInGenerics(ga, localGenerics))
+    } : {});
+  }
+  if (xlrNode.type === "object") {
+    const newProperties = {};
+    Object.getOwnPropertyNames(xlrNode.properties).forEach((propName) => {
+      const prop = xlrNode.properties[propName];
+      newProperties[propName] = {
+        required: prop.required,
+        node: fillInGenerics(prop.node, localGenerics)
+      };
+    });
+    return __spreadProps(__spreadValues({}, xlrNode), {
+      properties: newProperties
+    });
+  }
+  if (xlrNode.type === "array") {
+    xlrNode.elementType = fillInGenerics(xlrNode.elementType, localGenerics);
+  } else if (xlrNode.type === "or" || xlrNode.type === "and") {
+    let pointer;
+    if (xlrNode.type === "or") {
+      pointer = xlrNode.or;
+    } else {
+      pointer = xlrNode.and;
+    }
+    return __spreadProps(__spreadValues({}, xlrNode), {
+      [xlrNode.type]: pointer.map((prop) => {
+        return fillInGenerics(prop, localGenerics);
+      })
+    });
+  } else if (xlrNode.type === "record") {
+    return __spreadProps(__spreadValues({}, xlrNode), {
+      keyType: fillInGenerics(xlrNode.keyType, localGenerics),
+      valueType: fillInGenerics(xlrNode.valueType, localGenerics)
+    });
+  } else if (xlrNode.type === "conditional") {
+    const filledInConditional = __spreadProps(__spreadValues({}, xlrNode), {
+      check: {
+        left: fillInGenerics(xlrNode.check.left, localGenerics),
+        right: fillInGenerics(xlrNode.check.right, localGenerics)
+      },
+      value: {
+        true: fillInGenerics(xlrNode.value.true, localGenerics),
+        false: fillInGenerics(xlrNode.value.false, localGenerics)
+      }
+    });
+    if (filledInConditional.check.left.type !== "ref" && filledInConditional.check.right.type !== "ref") {
+      return __spreadValues({
+        name: xlrNode.name,
+        title: xlrNode.title
+      }, resolveConditional(filledInConditional));
+    }
+    return filledInConditional;
+  }
+  return xlrNode;
+}
+function applyPickOrOmitToNodeType(baseObject, operation, properties) {
+  if (baseObject.type === "object") {
+    const newObject = __spreadValues({}, baseObject);
+    Object.keys(baseObject.properties).forEach((key) => {
+      if (operation === "Omit" && properties.has(key) || operation === "Pick" && !properties.has(key)) {
+        delete newObject.properties[key];
+      }
+    });
+    if (Object.keys(newObject.properties).length === 0 && (operation !== "Omit" || newObject.additionalProperties === false)) {
+      return void 0;
+    }
+    return newObject;
+  }
+  let pointer;
+  if (baseObject.type === "and") {
+    pointer = baseObject.and;
+  } else if (baseObject.type === "or") {
+    pointer = baseObject.or;
+  } else {
+    throw new Error(`Error: Can not apply ${operation} to type ${baseObject.type}`);
+  }
+  const pickedTypes = pointer.map((type) => {
+    const node = applyPickOrOmitToNodeType(type, operation, properties);
+    if (node === void 0) {
+      return void 0;
+    }
+    return __spreadProps(__spreadValues({}, node), { additionalProperties: false });
+  }).filter((type) => type !== void 0);
+  if (pickedTypes.length === 0) {
+    return void 0;
+  }
+  if (pickedTypes.length === 1) {
+    return pickedTypes[0];
+  }
+  if (baseObject.type === "and") {
+    return __spreadProps(__spreadValues({}, baseObject), { and: pickedTypes });
+  }
+  return __spreadProps(__spreadValues({}, baseObject), { or: pickedTypes });
+}
+function applyPartialOrRequiredToNodeType(baseObject, modifier) {
+  if (baseObject.type === "object") {
+    const newObject = __spreadValues({}, baseObject);
+    Object.keys(baseObject.properties).forEach((key) => {
+      newObject.properties[key].required = modifier;
+    });
+    return newObject;
+  }
+  if (baseObject.type === "and") {
+    const pickedTypes = baseObject.and.map((type) => applyPartialOrRequiredToNodeType(type, modifier));
+    return __spreadProps(__spreadValues({}, baseObject), { and: pickedTypes });
+  }
+  if (baseObject.type === "or") {
+    const pickedTypes = baseObject.or.map((type) => applyPartialOrRequiredToNodeType(type, modifier));
+    return __spreadProps(__spreadValues({}, baseObject), { or: pickedTypes });
+  }
+  throw new Error(`Error: Can not apply ${modifier ? "Required" : "Partial"} to type ${baseObject.type}`);
+}
+
+function setupTestEnv(sourceCode, mockFileName = "filename.ts") {
+  const sourceFile = ts__namespace.createSourceFile(mockFileName, sourceCode, ts__namespace.ScriptTarget.Latest, true);
+  const compilerHost = {
+    getSourceFile(filename) {
+      if (filename === mockFileName) {
+        return sourceFile;
+      }
+      return void 0;
+    },
+    writeFile(name, text, writeByteOrderMark) {
+    },
+    getDefaultLibFileName() {
+      return "lib.d.ts";
+    },
+    useCaseSensitiveFileNames() {
+      return false;
+    },
+    getCanonicalFileName(filename) {
+      return filename;
+    },
+    getCurrentDirectory() {
+      return "";
+    },
+    getNewLine() {
+      return "\n";
+    },
+    fileExists(fileName) {
+      if (fileName === mockFileName) {
+        return true;
+      }
+      return false;
+    },
+    readFile(fileName) {
+      if (fileName === mockFileName) {
+        return sourceCode;
+      }
+      return void 0;
+    }
+  };
+  const program = ts__namespace.createProgram([mockFileName], {}, compilerHost);
+  return { sf: sourceFile, tc: program.getTypeChecker() };
+}
+
+exports.applyPartialOrRequiredToNodeType = applyPartialOrRequiredToNodeType;
+exports.applyPickOrOmitToNodeType = applyPickOrOmitToNodeType;
+exports.buildTemplateRegex = buildTemplateRegex;
+exports.decorateNode = decorateNode;
+exports.fillInGenerics = fillInGenerics;
+exports.getReferencedType = getReferencedType;
+exports.getStringLiteralsFromUnion = getStringLiteralsFromUnion;
+exports.isExportedDeclaration = isExportedDeclaration;
+exports.isGenericInterfaceDeclaration = isGenericInterfaceDeclaration;
+exports.isGenericNamedType = isGenericNamedType;
+exports.isGenericNodeType = isGenericNodeType;
+exports.isGenericTypeDeclaration = isGenericTypeDeclaration;
+exports.isNode = isNode;
+exports.isNodeExported = isNodeExported;
+exports.isNonNullable = isNonNullable;
+exports.isOptionalProperty = isOptionalProperty;
+exports.isPrimitiveTypeNode = isPrimitiveTypeNode;
+exports.isTopLevelNode = isTopLevelNode;
+exports.isTypeReferenceGeneric = isTypeReferenceGeneric;
+exports.makePropertyMap = makePropertyMap;
+exports.propertyToTuple = propertyToTuple;
+exports.resolveConditional = resolveConditional;
+exports.setupTestEnv = setupTestEnv;
+exports.tsStripOptionalType = tsStripOptionalType;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+import * as ts from 'typescript';
+import ts__default from 'typescript';
+import { Annotations, NodeType, NodeTypeWithGenerics, NamedType, NamedTypeWithGenerics, PrimitiveTypes, ConditionalType } from '@player-tools/xlr';
+import { Node } from 'jsonc-parser';
+
+/**
+ * Converts JSDoc comments to strings
+ */
+declare function decorateNode(node: ts.Node): Annotations;
+
+/**
+ * Returns the required type or the optionally required type
+ */
+declare function tsStripOptionalType(node: ts.TypeNode): ts.TypeNode;
+/**
+ * Returns if the top level declaration is exported
+ */
+declare function isExportedDeclaration(node: ts.Statement): boolean;
+/**
+ * Returns if the node is exported from the source file
+ */
+declare function isNodeExported(node: ts.Node): boolean;
+/**
+ * Returns the actual type and will following import chains if needed
+ */
+declare function getReferencedType(node: ts.TypeReferenceNode, typeChecker: ts.TypeChecker): {
+    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration;
+    exported: boolean;
+} | undefined;
+/**
+ * Returns list of string literals from potential union of strings
+ */
+declare function getStringLiteralsFromUnion(node: ts.Node): Set<string>;
+/**
+ * Converts a format string into a regex that can be used to validate a given string matches the template
+ */
+declare function buildTemplateRegex(node: ts.TemplateLiteralTypeNode, typeChecker: ts.TypeChecker): string;
+/**
+ * Walks generics to fill in values from a combination of the default, constraint, and passed in map values
+ */
+declare function fillInGenerics(xlrNode: NodeType, generics?: Map<string, NodeType>): NodeType;
+/** Applies the TS `Pick` type to an interface/union/intersection */
+declare function applyPickOrOmitToNodeType(baseObject: NodeType, operation: 'Pick' | 'Omit', properties: Set<string>): NodeType | undefined;
+/** Applies the TS `Omit` type to an interface/union/intersection */
+declare function applyPartialOrRequiredToNodeType(baseObject: NodeType, modifier: boolean): NodeType;
+
+/**
+ * Returns if the Object Property is optional
+ */
+declare function isOptionalProperty(node: ts__default.PropertySignature): boolean;
+/**
+ * Returns if the node is an Interface or Type with Generics
+ */
+declare function isGenericInterfaceDeclaration(node: ts__default.InterfaceDeclaration): boolean;
+/**
+ * Returns if the node is an Type Declaration with Generics
+ */
+declare function isGenericTypeDeclaration(node: ts__default.TypeAliasDeclaration): boolean;
+/**
+ * Returns if the referenced type is a generic
+ */
+declare function isTypeReferenceGeneric(node: ts__default.TypeReferenceNode, typeChecker: ts__default.TypeChecker): boolean;
+declare type TopLevelDeclaration = ts__default.InterfaceDeclaration | ts__default.TypeAliasDeclaration;
+/**
+ * Returns if the node is an interface or a type declaration
+ */
+declare function isTopLevelNode(node: ts__default.Node): node is TopLevelDeclaration;
+/**
+ * Returns if the NodeType has generic tokens
+ */
+declare function isGenericNodeType<T extends NodeType = NodeType>(nt: NodeType): nt is NodeTypeWithGenerics<T>;
+/**
+ * Returns if the named type has generic tokens
+ */
+declare function isGenericNamedType<T extends NamedType = NamedType>(nt: NodeType): nt is NamedTypeWithGenerics<T>;
+/**
+ * Returns if the node is a `PrimitiveTypes`
+ */
+declare function isPrimitiveTypeNode(node: NodeType): node is PrimitiveTypes;
+/**
+ * Type Guard for non-null values
+ */
+declare function isNonNullable<T>(a: T | null | undefined): a is NonNullable<T>;
+
+interface PropertyNode {
+    /** Equivalent Property Name */
+    key: string;
+    /** Equivalent Property Value */
+    value: Node;
+}
+/**
+ * Takes a property node and returns the underlying Key/Value Pairs
+ */
+declare function propertyToTuple(node: Node): PropertyNode;
+/**
+ * Turns a node's children into a map for easy access
+ */
+declare function makePropertyMap(node: Node): Map<string, Node>;
+/**
+ * Checks if property is a leaf node or another node
+ */
+declare function isNode(obj: Node | string | number | boolean): obj is Node;
+/**
+ * Attempts to resolve a conditional type
+ */
+declare function resolveConditional(conditional: ConditionalType): NodeType;
+
+interface SetupReturnType {
+    /**
+     * Virtual source file containing the passed in text
+     */
+    sf: ts.SourceFile;
+    /**
+     * Type checker for the virtual program
+     */
+    tc: ts.TypeChecker;
+}
+/**
+ * Setups a virtual TS environment for tests
+ */
+declare function setupTestEnv(sourceCode: string, mockFileName?: string): {
+    sf: ts.SourceFile;
+    tc: ts.TypeChecker;
+};
+
+export { PropertyNode, SetupReturnType, TopLevelDeclaration, applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, setupTestEnv, tsStripOptionalType };