@player-tools/xlr 0.4.2-next.1 → 0.5.0-next.0

package/dist/cjs/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/xlr/types/src/index.ts
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/xlr/types/src/index.ts"],"sourcesContent":["export * from \"./core\";\nexport * from \"./utility\";\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/index.legacy-esm.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,31 +1,25 @@
 {
   "name": "@player-tools/xlr",
-  "version": "0.4.2-next.1",
-  "private": false,
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  },
-  "peerDependencies": {},
-  "dependencies": {
-    "@babel/runtime": "7.15.4"
-  },
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "typings": "dist/index.d.ts",
+  "version": "0.5.0-next.0",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/index.legacy-esm.js",
+  "types": "types/index.d.ts",
   "sideEffects": false,
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/player-ui/tools"
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/cjs/index.cjs"
+    }
   },
-  "bugs": {
-    "url": "https://github.com/player-ui/tools/issues"
+  "files": [
+    "dist",
+    "src",
+    "types"
+  ],
+  "dependencies": {
+    "tslib": "^2.6.2"
   },
-  "homepage": "https://player-ui.github.io",
-  "contributors": [
-    {
-      "name": "Ketan Reddy",
-      "url": "https://github.com/KetanReddy"
-    }
-  ]
+  "peerDependencies": {}
 }

package/src/core.ts

@@ -32,28 +32,28 @@ export interface TypeNode<Name = string> {
   type: Name;
 }
 
-export type AnyType = TypeNode<'any'> & CommonTypeInfo<any> & Annotations;
+export type AnyType = TypeNode<"any"> & CommonTypeInfo<any> & Annotations;
 
-export type UnknownType = TypeNode<'unknown'> &
+export type UnknownType = TypeNode<"unknown"> &
   CommonTypeInfo<unknown> &
   Annotations;
-export type UndefinedType = TypeNode<'undefined'> &
+export type UndefinedType = TypeNode<"undefined"> &
   CommonTypeInfo<undefined> &
   Annotations;
-export type NullType = TypeNode<'null'> & CommonTypeInfo<null> & Annotations;
-export type VoidType = TypeNode<'void'> & CommonTypeInfo<void> & Annotations;
-export type StringType = TypeNode<'string'> &
+export type NullType = TypeNode<"null"> & CommonTypeInfo<null> & Annotations;
+export type VoidType = TypeNode<"void"> & CommonTypeInfo<void> & Annotations;
+export type StringType = TypeNode<"string"> &
   CommonTypeInfo<string> &
   Annotations;
-export type NumberType = TypeNode<'number'> &
+export type NumberType = TypeNode<"number"> &
   CommonTypeInfo<number> &
   Annotations;
-export type BooleanType = TypeNode<'boolean'> &
+export type BooleanType = TypeNode<"boolean"> &
   CommonTypeInfo<boolean> &
   Annotations;
-export type NeverType = TypeNode<'never'> & CommonTypeInfo<never> & Annotations;
+export type NeverType = TypeNode<"never"> & CommonTypeInfo<never> & Annotations;
 
-export interface RefNode extends TypeNode<'ref'> {
+export interface RefNode extends TypeNode<"ref"> {
   /** Name of the referenced Type */
   ref: string;
   /** Parameters to potentially fill in a generic when it is resolved. Position is preserved */
@@ -69,7 +69,7 @@ export interface ObjectProperty {
   /** The type of the property */
   node: NodeType;
 }
-export interface ObjectNode extends TypeNode<'object'> {
+export interface ObjectNode extends TypeNode<"object"> {
   /** The properties associated with an object */
   properties: {
     [name: string]: ObjectProperty;
@@ -81,7 +81,7 @@ export interface ObjectNode extends TypeNode<'object'> {
 }
 export type ObjectType = ObjectNode & CommonTypeInfo<object> & Annotations;
 
-export interface ArrayNode extends TypeNode<'array'> {
+export interface ArrayNode extends TypeNode<"array"> {
   /** What types are allowed in the array */
   elementType: NodeType;
 }
@@ -89,7 +89,7 @@ export type ArrayType<T = unknown> = ArrayNode &
   CommonTypeInfo<Array<T>> &
   Annotations;
 
-export interface ConditionalNode extends TypeNode<'conditional'> {
+export interface ConditionalNode extends TypeNode<"conditional"> {
   /** The check arguments */
   check: {
     /** operator */
@@ -117,7 +117,7 @@ export interface TupleMember {
   optional?: boolean;
 }
 
-export interface TupleNode extends TypeNode<'tuple'> {
+export interface TupleNode extends TypeNode<"tuple"> {
   /** The types in the tuple */
   elementTypes: Array<TupleMember>;
   /** The minimum number of items */
@@ -129,24 +129,24 @@ export type TupleType<T extends unknown[] = unknown[]> = TupleNode &
   CommonTypeInfo<T> &
   Annotations;
 
-export type AndType = TypeNode<'and'> &
+export type AndType = TypeNode<"and"> &
   Annotations & {
     /** Nodes in intersection */
     and: NodeType[];
   };
-export type OrType = TypeNode<'or'> &
+export type OrType = TypeNode<"or"> &
   Annotations & {
     /** Nodes in the union */
     or: NodeType[];
   };
 
-export type TemplateLiteralType = TypeNode<'template'> &
+export type TemplateLiteralType = TypeNode<"template"> &
   Annotations & {
     /** String version of regex used to validate template */
     format: string;
   };
 
-export type RecordType = TypeNode<'record'> &
+export type RecordType = TypeNode<"record"> &
   Annotations & {
     /** Key types for the Record */
     keyType: NodeType;
@@ -165,7 +165,7 @@ export type FunctionTypeParameters = {
   default?: NodeType;
 };
 
-export type FunctionType = TypeNode<'function'> &
+export type FunctionType = TypeNode<"function"> &
   Annotations & {
     /** Types for the parameters, in order, for the function */
     parameters: Array<FunctionTypeParameters>;
@@ -207,10 +207,9 @@ export type NodeType =
   | ConditionalType
   | VoidType;
 
-export type NodeTypeStrings = Pick<NodeType, 'type'>['type'];
+export type NodeTypeStrings = Pick<NodeType, "type">["type"];
 
 export type NodeTypeMap = {
-  // eslint-disable-next-line jsdoc/require-jsdoc
   [K in NodeTypeStrings]: Extract<NodeType, { type: K }>;
 };
 

package/src/index.ts

@@ -1,2 +1,2 @@
-export * from './core';
-export * from './utility';
+export * from "./core";
+export * from "./utility";

package/src/utility.ts

@@ -1,4 +1,4 @@
-import type { NamedType, NodeType } from '.';
+import type { NamedType, NodeType } from ".";
 
 export type TransformFunction = (
   input: NamedType<NodeType> | NodeType,

package/types/core.d.ts

@@ -0,0 +1,172 @@
+export interface Annotations {
+    /** The name used to reference this type */
+    name?: string;
+    /** The path within a type to this type (may be the same as `name` ) */
+    title?: string;
+    /** The JSDoc string for this type */
+    description?: string;
+    /** The JSDoc `@example` string for this type */
+    examples?: string | Array<string>;
+    /** The JSDoc `@default` string for this type */
+    default?: string;
+    /** The JSDoc `@see` string for this type */
+    see?: string | Array<string>;
+    /** The Typescript comment associated with the type */
+    comment?: string;
+    /** The JSDoc `@meta` string for this type */
+    meta?: Record<string, string>;
+}
+export interface Const<T> {
+    /** The literal value for the node */
+    const?: T;
+}
+export interface Enum<T> {
+    /** The list of enums for the node */
+    enum?: Array<T>;
+}
+export type CommonTypeInfo<T> = Const<T> & Enum<T>;
+export interface TypeNode<Name = string> {
+    /** The type of Node */
+    type: Name;
+}
+export type AnyType = TypeNode<"any"> & CommonTypeInfo<any> & Annotations;
+export type UnknownType = TypeNode<"unknown"> & CommonTypeInfo<unknown> & Annotations;
+export type UndefinedType = TypeNode<"undefined"> & CommonTypeInfo<undefined> & Annotations;
+export type NullType = TypeNode<"null"> & CommonTypeInfo<null> & Annotations;
+export type VoidType = TypeNode<"void"> & CommonTypeInfo<void> & Annotations;
+export type StringType = TypeNode<"string"> & CommonTypeInfo<string> & Annotations;
+export type NumberType = TypeNode<"number"> & CommonTypeInfo<number> & Annotations;
+export type BooleanType = TypeNode<"boolean"> & CommonTypeInfo<boolean> & Annotations;
+export type NeverType = TypeNode<"never"> & CommonTypeInfo<never> & Annotations;
+export interface RefNode extends TypeNode<"ref"> {
+    /** Name of the referenced Type */
+    ref: string;
+    /** Parameters to potentially fill in a generic when it is resolved. Position is preserved */
+    genericArguments?: Array<NodeType>;
+    /** Optional property to access when the reference is resolved */
+    property?: string;
+}
+export type RefType = RefNode & Annotations;
+export interface ObjectProperty {
+    /** If this property is required */
+    required: boolean;
+    /** The type of the property */
+    node: NodeType;
+}
+export interface ObjectNode extends TypeNode<"object"> {
+    /** The properties associated with an object */
+    properties: {
+        [name: string]: ObjectProperty;
+    };
+    /** A custom primitive that this object extends that is to be resolved when used */
+    extends?: RefType;
+    /** What type, if any, of additional properties are allowed on the object */
+    additionalProperties: false | NodeType;
+}
+export type ObjectType = ObjectNode & CommonTypeInfo<object> & Annotations;
+export interface ArrayNode extends TypeNode<"array"> {
+    /** What types are allowed in the array */
+    elementType: NodeType;
+}
+export type ArrayType<T = unknown> = ArrayNode & CommonTypeInfo<Array<T>> & Annotations;
+export interface ConditionalNode extends TypeNode<"conditional"> {
+    /** The check arguments */
+    check: {
+        /** operator */
+        left: NodeType;
+        /** operand */
+        right: NodeType;
+    };
+    /** The resulting values to use */
+    value: {
+        /** If the conditional is true */
+        true: NodeType;
+        /** If the conditional is false */
+        false: NodeType;
+    };
+}
+export type ConditionalType = ConditionalNode & Annotations;
+export interface TupleMember {
+    /** Optional Name of the Tuple Member */
+    name?: string;
+    /** Type constraint of the Tuple Member */
+    type: NodeType;
+    /** Is the Tuple Member Optional */
+    optional?: boolean;
+}
+export interface TupleNode extends TypeNode<"tuple"> {
+    /** The types in the tuple */
+    elementTypes: Array<TupleMember>;
+    /** The minimum number of items */
+    minItems: number;
+    /** What, if any, additional types can be provided */
+    additionalItems: false | NodeType;
+}
+export type TupleType<T extends unknown[] = unknown[]> = TupleNode & CommonTypeInfo<T> & Annotations;
+export type AndType = TypeNode<"and"> & Annotations & {
+    /** Nodes in intersection */
+    and: NodeType[];
+};
+export type OrType = TypeNode<"or"> & Annotations & {
+    /** Nodes in the union */
+    or: NodeType[];
+};
+export type TemplateLiteralType = TypeNode<"template"> & Annotations & {
+    /** String version of regex used to validate template */
+    format: string;
+};
+export type RecordType = TypeNode<"record"> & Annotations & {
+    /** Key types for the Record */
+    keyType: NodeType;
+    /** Value types for the Record */
+    valueType: NodeType;
+};
+export type FunctionTypeParameters = {
+    /** String name of the function parameter */
+    name: string;
+    /** The type constraint of the parameter */
+    type: NodeType;
+    /** Indicates that the parameter is optional */
+    optional?: true;
+    /** Default value for the parameter if nothing is supplied */
+    default?: NodeType;
+};
+export type FunctionType = TypeNode<"function"> & Annotations & {
+    /** Types for the parameters, in order, for the function */
+    parameters: Array<FunctionTypeParameters>;
+    /** Return type of the function */
+    returnType?: NodeType;
+};
+/** Primitive Type Nodes */
+export type PrimitiveTypes = NeverType | NullType | StringType | NumberType | BooleanType | AnyType | UnknownType | UndefinedType | VoidType;
+/** Set of all Node Types */
+export type NodeType = AnyType | UnknownType | UndefinedType | NullType | NeverType | StringType | TemplateLiteralType | NumberType | BooleanType | ObjectType | ArrayType | TupleType | RecordType | AndType | OrType | RefType | FunctionType | ConditionalType | VoidType;
+export type NodeTypeStrings = Pick<NodeType, "type">["type"];
+export type NodeTypeMap = {
+    [K in NodeTypeStrings]: Extract<NodeType, {
+        type: K;
+    }>;
+};
+export type NamedType<T extends NodeType = NodeType> = T & {
+    /** Name of the exported interface/type */
+    name: string;
+    /** File the type was exported from */
+    source: string;
+};
+export interface ParamTypeNode {
+    /** Symbol used to identify the generic in the interface/type */
+    symbol: string;
+    /** The type constraint for the generic */
+    constraints?: NodeType;
+    /** The default value for the generic if no value is provided */
+    default?: NodeType;
+}
+export type NamedTypeWithGenerics<T extends NodeType = NodeType> = NamedType<T> & {
+    /** Generics for the Named Type that need to be filled in */
+    genericTokens: Array<ParamTypeNode>;
+};
+export type NodeTypeWithGenerics<T extends NodeType = NodeType> = T & {
+    /** Generics for the Node that need to be filled in */
+    genericTokens: Array<ParamTypeNode>;
+};
+//# sourceMappingURL=core.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core";
+export * from "./utility";
+//# sourceMappingURL=index.d.ts.map

package/types/utility.d.ts

@@ -0,0 +1,25 @@
+import type { NamedType, NodeType } from ".";
+export type TransformFunction = (input: NamedType<NodeType> | NodeType, capabilityType: string) => NamedType | NodeType;
+export interface Capability {
+    /** Name of the capability that is provided to Player */
+    name: string;
+    /** List of XLRs that are provided for the Capability */
+    provides: Array<string>;
+}
+export interface Manifest {
+    /** Name of the plugin */
+    pluginName: string;
+    /** Map of capabilities provided by the plugin to the name of the XLR for the capabilities */
+    capabilities?: Map<string, Array<string>>;
+    /** CustomPrimitives that are the most basic types in the Payer Ecosystem */
+    customPrimitives?: Array<string>;
+}
+export interface TSManifest {
+    /** Name of the plugin */
+    pluginName: string;
+    /** Index of capabilities provided by the plugin to the name of the XLR for the capabilities */
+    capabilities: {
+        [capability: string]: Array<NamedType>;
+    };
+}
+//# sourceMappingURL=utility.d.ts.map

package/README.md

@@ -1,3 +0,0 @@
-# @player-tools/xlr
-
-Type definitions for the XLR AST Nodes and other cross package definitions. 

package/dist/index.cjs.js

@@ -1,3 +0,0 @@
-'use strict';
-
-//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -1,197 +0,0 @@
-interface Annotations {
-    /** The name used to reference this type */
-    name?: string;
-    /** The path within a type to this type (may be the same as `name` ) */
-    title?: string;
-    /** The JSDoc string for this type */
-    description?: string;
-    /** The JSDoc `@example` string for this type */
-    examples?: string | Array<string>;
-    /** The JSDoc `@default` string for this type */
-    default?: string;
-    /** The JSDoc `@see` string for this type */
-    see?: string | Array<string>;
-    /** The Typescript comment associated with the type */
-    comment?: string;
-    /** The JSDoc `@meta` string for this type */
-    meta?: Record<string, string>;
-}
-interface Const<T> {
-    /** The literal value for the node */
-    const?: T;
-}
-interface Enum<T> {
-    /** The list of enums for the node */
-    enum?: Array<T>;
-}
-declare type CommonTypeInfo<T> = Const<T> & Enum<T>;
-interface TypeNode<Name = string> {
-    /** The type of Node */
-    type: Name;
-}
-declare type AnyType = TypeNode<'any'> & CommonTypeInfo<any> & Annotations;
-declare type UnknownType = TypeNode<'unknown'> & CommonTypeInfo<unknown> & Annotations;
-declare type UndefinedType = TypeNode<'undefined'> & CommonTypeInfo<undefined> & Annotations;
-declare type NullType = TypeNode<'null'> & CommonTypeInfo<null> & Annotations;
-declare type VoidType = TypeNode<'void'> & CommonTypeInfo<void> & Annotations;
-declare type StringType = TypeNode<'string'> & CommonTypeInfo<string> & Annotations;
-declare type NumberType = TypeNode<'number'> & CommonTypeInfo<number> & Annotations;
-declare type BooleanType = TypeNode<'boolean'> & CommonTypeInfo<boolean> & Annotations;
-declare type NeverType = TypeNode<'never'> & CommonTypeInfo<never> & Annotations;
-interface RefNode extends TypeNode<'ref'> {
-    /** Name of the referenced Type */
-    ref: string;
-    /** Parameters to potentially fill in a generic when it is resolved. Position is preserved */
-    genericArguments?: Array<NodeType>;
-    /** Optional property to access when the reference is resolved */
-    property?: string;
-}
-declare type RefType = RefNode & Annotations;
-interface ObjectProperty {
-    /** If this property is required */
-    required: boolean;
-    /** The type of the property */
-    node: NodeType;
-}
-interface ObjectNode extends TypeNode<'object'> {
-    /** The properties associated with an object */
-    properties: {
-        [name: string]: ObjectProperty;
-    };
-    /** A custom primitive that this object extends that is to be resolved when used */
-    extends?: RefType;
-    /** What type, if any, of additional properties are allowed on the object */
-    additionalProperties: false | NodeType;
-}
-declare type ObjectType = ObjectNode & CommonTypeInfo<object> & Annotations;
-interface ArrayNode extends TypeNode<'array'> {
-    /** What types are allowed in the array */
-    elementType: NodeType;
-}
-declare type ArrayType<T = unknown> = ArrayNode & CommonTypeInfo<Array<T>> & Annotations;
-interface ConditionalNode extends TypeNode<'conditional'> {
-    /** The check arguments */
-    check: {
-        /** operator */
-        left: NodeType;
-        /** operand */
-        right: NodeType;
-    };
-    /** The resulting values to use */
-    value: {
-        /** If the conditional is true */
-        true: NodeType;
-        /** If the conditional is false */
-        false: NodeType;
-    };
-}
-declare type ConditionalType = ConditionalNode & Annotations;
-interface TupleMember {
-    /** Optional Name of the Tuple Member */
-    name?: string;
-    /** Type constraint of the Tuple Member */
-    type: NodeType;
-    /** Is the Tuple Member Optional */
-    optional?: boolean;
-}
-interface TupleNode extends TypeNode<'tuple'> {
-    /** The types in the tuple */
-    elementTypes: Array<TupleMember>;
-    /** The minimum number of items */
-    minItems: number;
-    /** What, if any, additional types can be provided */
-    additionalItems: false | NodeType;
-}
-declare type TupleType<T extends unknown[] = unknown[]> = TupleNode & CommonTypeInfo<T> & Annotations;
-declare type AndType = TypeNode<'and'> & Annotations & {
-    /** Nodes in intersection */
-    and: NodeType[];
-};
-declare type OrType = TypeNode<'or'> & Annotations & {
-    /** Nodes in the union */
-    or: NodeType[];
-};
-declare type TemplateLiteralType = TypeNode<'template'> & Annotations & {
-    /** String version of regex used to validate template */
-    format: string;
-};
-declare type RecordType = TypeNode<'record'> & Annotations & {
-    /** Key types for the Record */
-    keyType: NodeType;
-    /** Value types for the Record */
-    valueType: NodeType;
-};
-declare type FunctionTypeParameters = {
-    /** String name of the function parameter */
-    name: string;
-    /** The type constraint of the parameter */
-    type: NodeType;
-    /** Indicates that the parameter is optional */
-    optional?: true;
-    /** Default value for the parameter if nothing is supplied */
-    default?: NodeType;
-};
-declare type FunctionType = TypeNode<'function'> & Annotations & {
-    /** Types for the parameters, in order, for the function */
-    parameters: Array<FunctionTypeParameters>;
-    /** Return type of the function */
-    returnType?: NodeType;
-};
-/** Primitive Type Nodes */
-declare type PrimitiveTypes = NeverType | NullType | StringType | NumberType | BooleanType | AnyType | UnknownType | UndefinedType | VoidType;
-/** Set of all Node Types */
-declare type NodeType = AnyType | UnknownType | UndefinedType | NullType | NeverType | StringType | TemplateLiteralType | NumberType | BooleanType | ObjectType | ArrayType | TupleType | RecordType | AndType | OrType | RefType | FunctionType | ConditionalType | VoidType;
-declare type NodeTypeStrings = Pick<NodeType, 'type'>['type'];
-declare type NodeTypeMap = {
-    [K in NodeTypeStrings]: Extract<NodeType, {
-        type: K;
-    }>;
-};
-declare type NamedType<T extends NodeType = NodeType> = T & {
-    /** Name of the exported interface/type */
-    name: string;
-    /** File the type was exported from */
-    source: string;
-};
-interface ParamTypeNode {
-    /** Symbol used to identify the generic in the interface/type */
-    symbol: string;
-    /** The type constraint for the generic */
-    constraints?: NodeType;
-    /** The default value for the generic if no value is provided */
-    default?: NodeType;
-}
-declare type NamedTypeWithGenerics<T extends NodeType = NodeType> = NamedType<T> & {
-    /** Generics for the Named Type that need to be filled in */
-    genericTokens: Array<ParamTypeNode>;
-};
-declare type NodeTypeWithGenerics<T extends NodeType = NodeType> = T & {
-    /** Generics for the Node that need to be filled in */
-    genericTokens: Array<ParamTypeNode>;
-};
-
-declare type TransformFunction = (input: NamedType<NodeType> | NodeType, capabilityType: string) => NamedType | NodeType;
-interface Capability {
-    /** Name of the capability that is provided to Player */
-    name: string;
-    /** List of XLRs that are provided for the Capability */
-    provides: Array<string>;
-}
-interface Manifest {
-    /** Name of the plugin */
-    pluginName: string;
-    /** Map of capabilities provided by the plugin to the name of the XLR for the capabilities */
-    capabilities?: Map<string, Array<string>>;
-    /** CustomPrimitives that are the most basic types in the Payer Ecosystem */
-    customPrimitives?: Array<string>;
-}
-interface TSManifest {
-    /** Name of the plugin */
-    pluginName: string;
-    /** Index of capabilities provided by the plugin to the name of the XLR for the capabilities */
-    capabilities: {
-        [capability: string]: Array<NamedType>;
-    };
-}
-
-export { AndType, Annotations, AnyType, ArrayNode, ArrayType, BooleanType, Capability, CommonTypeInfo, ConditionalNode, ConditionalType, Const, Enum, FunctionType, FunctionTypeParameters, Manifest, NamedType, NamedTypeWithGenerics, NeverType, NodeType, NodeTypeMap, NodeTypeStrings, NodeTypeWithGenerics, NullType, NumberType, ObjectNode, ObjectProperty, ObjectType, OrType, ParamTypeNode, PrimitiveTypes, RecordType, RefNode, RefType, StringType, TSManifest, TemplateLiteralType, TransformFunction, TupleMember, TupleNode, TupleType, TypeNode, UndefinedType, UnknownType, VoidType };

package/dist/index.esm.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=index.esm.js.map