schemair 0.1.0 → 0.3.0

package/dist/index-1sDuqu05.d.ts

@@ -0,0 +1,373 @@
+//#region src/spec/schema.d.ts
+/** JSON values allowed in opaque constraint arguments. */
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type PrimitiveName = 'string' | 'number' | 'boolean' | 'null';
+type LiteralValue = string | number | boolean;
+interface SchemaConstraint {
+  constraintPath: string[];
+  args?: JsonValue;
+}
+interface SchemaStringNode {
+  kind: 'primitive';
+  name: 'string';
+  semanticPath?: string[];
+  constraints?: SchemaConstraint[];
+}
+interface SchemaNumberNode {
+  kind: 'primitive';
+  name: 'number';
+  semanticPath?: string[];
+  constraints?: SchemaConstraint[];
+}
+interface SchemaBooleanNode {
+  kind: 'primitive';
+  name: 'boolean';
+}
+interface SchemaNullNode {
+  kind: 'primitive';
+  name: 'null';
+}
+type SchemaPrimitiveNode = SchemaStringNode | SchemaNumberNode | SchemaBooleanNode | SchemaNullNode;
+interface SchemaLiteralNode {
+  kind: 'literal';
+  literal: LiteralValue;
+}
+interface SchemaRecordField {
+  key: string;
+  schema: SchemaNode;
+  required?: boolean;
+  description?: string;
+}
+interface SchemaRecordNode {
+  kind: 'record';
+  fields: SchemaRecordField[];
+  additionalFields?: true | SchemaNode;
+  constraints?: SchemaConstraint[];
+}
+interface SchemaArrayNode {
+  kind: 'array';
+  elementSchema: SchemaNode;
+  constraints?: SchemaConstraint[];
+}
+interface SchemaTupleNode {
+  kind: 'tuple';
+  elementSchemas: SchemaNode[];
+}
+interface SchemaLiteralUnionNode {
+  kind: 'literalUnion';
+  values: [LiteralValue, LiteralValue, ...LiteralValue[]];
+}
+interface SchemaNullableNode {
+  kind: 'nullable';
+  value: SchemaNode;
+}
+interface SchemaTaggedUnionVariant {
+  key: string;
+  schema: SchemaRecordNode;
+  description?: string;
+}
+interface SchemaTaggedUnionNode {
+  kind: 'taggedUnion';
+  discriminator: string;
+  variants: SchemaTaggedUnionVariant[];
+}
+interface SchemaRefNode {
+  kind: 'ref';
+  refPath: string[];
+}
+interface SchemaSelfRefNode {
+  kind: 'selfRef';
+}
+/** Closed serializable SchemaIR contract model. */
+type SchemaNode = SchemaPrimitiveNode | SchemaLiteralNode | SchemaRecordNode | SchemaArrayNode | SchemaTupleNode | SchemaLiteralUnionNode | SchemaNullableNode | SchemaTaggedUnionNode | SchemaRefNode | SchemaSelfRefNode;
+/** A host-provided schema bound for an external `refPath`. */
+interface SchemaRefEntry {
+  readonly refPath: readonly string[];
+  readonly schema: SchemaNode;
+}
+//#endregion
+//#region src/spec/operation.d.ts
+type OperationBinaryMetadata = {
+  kind: 'mime';
+  value: string;
+};
+type OperationPayloadDefinition = StructuredOperationPayloadDefinition | {
+  kind: 'binary';
+  meta?: OperationBinaryMetadata;
+};
+interface OperationErrorDefinition {
+  description?: string;
+  data?: SchemaNode;
+}
+interface OperationChannelDefinition {
+  description?: string;
+  data?: OperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+}
+interface OperationDefinition {
+  description?: string;
+  input?: OperationPayloadDefinition;
+  output?: OperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+  emits?: Record<string, OperationChannelDefinition>;
+}
+/** Short model name used by migration-facing APIs. */
+type Operation = OperationDefinition;
+interface OperationContainerDefinition {
+  description?: string;
+  operations?: Record<string, OperationDefinition>;
+  containers?: Record<string, OperationContainerDefinition>;
+}
+interface StructuredOperationPayloadDefinition {
+  kind: 'structured';
+  schema: SchemaNode;
+}
+interface StructuredOperationChannelDefinition {
+  description?: string;
+  data?: StructuredOperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+}
+interface StructuredOperationDefinition {
+  description?: string;
+  input?: StructuredOperationPayloadDefinition;
+  output?: StructuredOperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+  emits?: Record<string, StructuredOperationChannelDefinition>;
+}
+interface StructuredOperationContainerDefinition {
+  description?: string;
+  operations?: Record<string, StructuredOperationDefinition>;
+  containers?: Record<string, StructuredOperationContainerDefinition>;
+}
+//#endregion
+//#region src/spec/expression.d.ts
+interface SchemaTypeVariableExpr {
+  kind: 'typeVar';
+  name: string;
+  extends?: SchemaTypeTerm;
+}
+interface SchemaTypeOpaqueHostExpr {
+  kind: 'opaqueHostType';
+  hostPath: string[];
+}
+interface SchemaTypeAbsentExpr {
+  kind: 'absent';
+}
+interface SchemaTypeNeverExpr {
+  kind: 'never';
+}
+interface SchemaTypeUnknownExpr {
+  kind: 'unknown';
+}
+interface SchemaTypeMaybeAbsentExpr {
+  kind: 'maybeAbsent';
+  value: SchemaTypeTerm;
+}
+interface SchemaTypeArrayExpr {
+  kind: 'arrayOf';
+  element: SchemaTypeTerm;
+  constraints?: SchemaConstraint[];
+}
+interface SchemaTypeTupleExpr {
+  kind: 'tupleOf';
+  elements: SchemaTypeTerm[];
+}
+interface SchemaTypeRecordExpr {
+  kind: 'recordOf';
+  fields: {
+    key: string;
+    value: SchemaTypeTerm;
+    required?: boolean;
+    description?: string;
+  }[];
+  additionalFields?: true | SchemaTypeTerm;
+  constraints?: SchemaConstraint[];
+}
+type SchemaFieldSelector = {
+  kind: 'all';
+} | {
+  kind: 'keys';
+  keys: string[];
+  onMissing: 'error' | 'ignore';
+};
+type SchemaVariantSelector = SchemaFieldSelector;
+interface SchemaTypeElementOfExpr {
+  kind: 'elementOf';
+  source: SchemaTypeTerm;
+}
+interface SchemaTypeValueOfExpr {
+  kind: 'valueOf';
+  source: SchemaTypeTerm;
+}
+interface SchemaTypeElementAtExpr {
+  kind: 'elementAt';
+  source: SchemaTypeTerm;
+  index: number;
+}
+interface SchemaTypeFieldOfExpr {
+  kind: 'fieldOf';
+  source: SchemaTypeTerm;
+  key: string;
+}
+interface SchemaTypeKeyOfExpr {
+  kind: 'keyOf';
+  source: SchemaTypeTerm;
+}
+interface SchemaTypeFieldsOfExpr {
+  kind: 'fieldsOf';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypePickFieldsExpr {
+  kind: 'pickFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypeOmitFieldsExpr {
+  kind: 'omitFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypePartialFieldsExpr {
+  kind: 'partialFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypeRequiredFieldsExpr {
+  kind: 'requiredFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypeMergeRecordsExpr {
+  kind: 'mergeRecords';
+  sources: SchemaTypeTerm[];
+  conflict: 'leftWins' | 'rightWins' | 'error';
+}
+interface SchemaTypeNullableExpr {
+  kind: 'nullableOf';
+  value: SchemaTypeTerm;
+}
+interface SchemaTypeTaggedUnionExpr {
+  kind: 'taggedUnionOf';
+  discriminator: string;
+  variants: {
+    key: string;
+    value: SchemaTypeTerm;
+    description?: string;
+  }[];
+}
+interface SchemaTypeIntersectExpr {
+  kind: 'intersect';
+  sources: SchemaTypeTerm[];
+}
+interface SchemaTypeRefineExpr {
+  kind: 'refine';
+  source: SchemaTypeTerm;
+  fields: {
+    key: string;
+    require?: true;
+    intersectWith?: SchemaTypeTerm;
+    addConstraints?: SchemaConstraint[];
+  }[];
+}
+interface SchemaTypeExcludeVariantsExpr {
+  kind: 'excludeVariants';
+  source: SchemaTypeTerm;
+  variants: SchemaVariantSelector;
+}
+interface SchemaTypeExtractVariantsExpr {
+  kind: 'extractVariants';
+  source: SchemaTypeTerm;
+  variants: SchemaVariantSelector;
+}
+type SchemaTypeExpr = SchemaTypeVariableExpr | SchemaTypeOpaqueHostExpr | SchemaTypeAbsentExpr | SchemaTypeNeverExpr | SchemaTypeUnknownExpr | SchemaTypeMaybeAbsentExpr | SchemaTypeArrayExpr | SchemaTypeTupleExpr | SchemaTypeRecordExpr | SchemaTypeElementOfExpr | SchemaTypeValueOfExpr | SchemaTypeElementAtExpr | SchemaTypeFieldOfExpr | SchemaTypeKeyOfExpr | SchemaTypeFieldsOfExpr | SchemaTypePickFieldsExpr | SchemaTypeOmitFieldsExpr | SchemaTypePartialFieldsExpr | SchemaTypeRequiredFieldsExpr | SchemaTypeMergeRecordsExpr | SchemaTypeNullableExpr | SchemaTypeTaggedUnionExpr | SchemaTypeIntersectExpr | SchemaTypeRefineExpr | SchemaTypeExcludeVariantsExpr | SchemaTypeExtractVariantsExpr;
+type SchemaTypeTerm = SchemaNode | SchemaTypeExpr;
+/** Short model name used by migration-facing APIs. */
+type Expression = SchemaTypeExpr;
+/** Kept here so consumers can share the JSON-compatible expression boundary. */
+type ExpressionArgument = JsonValue;
+//#endregion
+//#region src/spec/standard/paths.d.ts
+declare const STANDARD_SEMANTIC_PATHS: {
+  readonly string: {
+    readonly date: readonly ["std", "string", "date"];
+    readonly datetime: readonly ["std", "string", "datetime"];
+    readonly datetimeIso: readonly ["std", "string", "datetime", "iso"];
+    readonly email: readonly ["std", "string", "email"];
+    readonly url: readonly ["std", "string", "url"];
+    readonly ipV4: readonly ["std", "string", "ip", "v4"];
+    readonly ipV6: readonly ["std", "string", "ip", "v6"];
+    readonly uuid: readonly ["std", "string", "uuid"];
+    readonly uuidV4: readonly ["std", "string", "uuid", "v4"];
+    readonly json: readonly ["std", "string", "json"];
+    readonly base64: readonly ["std", "string", "base64"];
+    readonly base64url: readonly ["std", "string", "base64url"];
+    readonly hex: readonly ["std", "string", "hex"];
+    readonly decimal: readonly ["std", "string", "decimal"];
+    readonly bigint: readonly ["std", "string", "bigint"];
+    readonly secret: readonly ["std", "string", "secret"];
+    readonly token: readonly ["std", "string", "secret", "token"];
+    readonly password: readonly ["std", "string", "secret", "password"];
+  };
+  readonly number: {
+    readonly integer: readonly ["std", "number", "integer"];
+    readonly safeInteger: readonly ["std", "number", "safeInteger"];
+    readonly epochMillis: readonly ["std", "number", "epochMillis"];
+    readonly epochSeconds: readonly ["std", "number", "epochSeconds"];
+  };
+};
+declare const STANDARD_SEMANTIC_PATH_LIST: ReadonlyArray<readonly string[]>;
+declare const STANDARD_CONSTRAINT_PATHS: {
+  readonly string: {
+    readonly minLength: readonly ["std", "minLength"];
+    readonly maxLength: readonly ["std", "maxLength"];
+    readonly pattern: readonly ["std", "pattern"];
+  };
+  readonly number: {
+    readonly minimum: readonly ["std", "minimum"];
+    readonly maximum: readonly ["std", "maximum"];
+    readonly exclusiveMinimum: readonly ["std", "exclusiveMinimum"];
+    readonly exclusiveMaximum: readonly ["std", "exclusiveMaximum"];
+    readonly multipleOf: readonly ["std", "multipleOf"];
+  };
+  readonly array: {
+    readonly minItems: readonly ["std", "minItems"];
+    readonly maxItems: readonly ["std", "maxItems"];
+    readonly uniqueItems: readonly ["std", "uniqueItems"];
+  };
+  readonly record: {
+    readonly minProperties: readonly ["std", "minProperties"];
+    readonly maxProperties: readonly ["std", "maxProperties"];
+  };
+};
+declare const STANDARD_CONSTRAINT_PATH_LIST: ReadonlyArray<readonly string[]>;
+//#endregion
+//#region src/spec/standard/definitions.d.ts
+interface StandardSemanticDefinition {
+  path: readonly string[];
+  label: string;
+  description: string;
+  primitive: 'string' | 'number';
+  role: 'validation' | 'annotation';
+}
+interface StandardSemanticRelation {
+  source: readonly string[];
+  target: readonly string[];
+  kind: 'acceptedSetSubset';
+}
+interface StandardConstraintDefinition {
+  path: readonly string[];
+  label: string;
+  description: string;
+  target: 'string' | 'number' | 'array' | 'record';
+  argsType: 'number' | 'string' | 'boolean';
+  argsDomain: 'finiteNumber' | 'nonNegativeInteger' | 'positiveNumber' | 'regexSource' | 'boolean';
+}
+declare const STANDARD_SEMANTIC_DEFINITIONS: ReadonlyArray<StandardSemanticDefinition>;
+/** Explicit accepted-set implications; carrier types are not semantic paths. */
+declare const STANDARD_SEMANTIC_RELATIONS: ReadonlyArray<StandardSemanticRelation>;
+declare const STANDARD_CONSTRAINT_DEFINITIONS: ReadonlyArray<StandardConstraintDefinition>;
+//#endregion
+export { StructuredOperationPayloadDefinition as $, SchemaTypeOpaqueHostExpr as A, SchemaTypeValueOfExpr as B, SchemaTypeIntersectExpr as C, SchemaTypeNeverExpr as D, SchemaTypeMergeRecordsExpr as E, SchemaTypeRequiredFieldsExpr as F, OperationChannelDefinition as G, SchemaVariantSelector as H, SchemaTypeTaggedUnionExpr as I, OperationErrorDefinition as J, OperationContainerDefinition as K, SchemaTypeTerm as L, SchemaTypePickFieldsExpr as M, SchemaTypeRecordExpr as N, SchemaTypeNullableExpr as O, SchemaTypeRefineExpr as P, StructuredOperationDefinition as Q, SchemaTypeTupleExpr as R, SchemaTypeFieldsOfExpr as S, SchemaTypeMaybeAbsentExpr as T, Operation as U, SchemaTypeVariableExpr as V, OperationBinaryMetadata as W, StructuredOperationChannelDefinition as X, OperationPayloadDefinition as Y, StructuredOperationContainerDefinition as Z, SchemaTypeElementOfExpr as _, SchemaSelfRefNode as _t, StandardSemanticDefinition as a, SchemaConstraint as at, SchemaTypeExtractVariantsExpr as b, SchemaTaggedUnionVariant as bt, STANDARD_CONSTRAINT_PATH_LIST as c, SchemaNode as ct, Expression as d, SchemaNumberNode as dt, JsonValue as et, ExpressionArgument as f, SchemaPrimitiveNode as ft, SchemaTypeElementAtExpr as g, SchemaRefNode as gt, SchemaTypeArrayExpr as h, SchemaRefEntry as ht, StandardConstraintDefinition as i, SchemaBooleanNode as it, SchemaTypePartialFieldsExpr as j, SchemaTypeOmitFieldsExpr as k, STANDARD_SEMANTIC_PATHS as l, SchemaNullNode as lt, SchemaTypeAbsentExpr as m, SchemaRecordNode as mt, STANDARD_SEMANTIC_DEFINITIONS as n, PrimitiveName as nt, StandardSemanticRelation as o, SchemaLiteralNode as ot, SchemaFieldSelector as p, SchemaRecordField as pt, OperationDefinition as q, STANDARD_SEMANTIC_RELATIONS as r, SchemaArrayNode as rt, STANDARD_CONSTRAINT_PATHS as s, SchemaLiteralUnionNode as st, STANDARD_CONSTRAINT_DEFINITIONS as t, LiteralValue as tt, STANDARD_SEMANTIC_PATH_LIST as u, SchemaNullableNode as ut, SchemaTypeExcludeVariantsExpr as v, SchemaStringNode as vt, SchemaTypeKeyOfExpr as w, SchemaTypeFieldOfExpr as x, SchemaTupleNode as xt, SchemaTypeExpr as y, SchemaTaggedUnionNode as yt, SchemaTypeUnknownExpr as z };

package/dist/index-BFSMT_2d.d.ts

@@ -0,0 +1,53 @@
+import { ct as SchemaNode, gt as SchemaRefNode, ht as SchemaRefEntry, q as OperationDefinition } from "./index-1sDuqu05.js";
+
+//#region src/resolve/schema-closure.d.ts
+interface SchemaClosureDiagnostic {
+  readonly code: string;
+  readonly path: readonly (string | number)[];
+  readonly message: string;
+}
+type SchemaRefResolution = SchemaNode | {
+  readonly status: 'resolved';
+  readonly schema: SchemaNode;
+} | {
+  readonly status: 'unknown' | 'unsupported';
+  readonly message?: string;
+} | undefined;
+interface ResolvedSchemaGraph {
+  readonly refs: readonly SchemaRefEntry[];
+  /** External graph edges that point back to an active ref during loading. */
+  readonly cycles: readonly (readonly string[])[];
+}
+type SchemaClosureStatus = 'resolved' | 'incomplete' | 'rejected';
+interface SchemaClosureResult {
+  readonly status: SchemaClosureStatus;
+  readonly graph: ResolvedSchemaGraph;
+  readonly issues: readonly SchemaClosureDiagnostic[];
+}
+interface SchemaClosureContext {
+  readonly resolveRef?: (refPath: readonly string[], context: SchemaClosureResolutionContext) => SchemaRefResolution;
+  readonly refs?: readonly SchemaRefEntry[];
+  readonly maxDepth?: number;
+  readonly maxNodes?: number;
+  readonly maxSteps?: number;
+}
+/** Async loading accepts both synchronous and asynchronous host resolvers. */
+interface AsyncSchemaClosureContext extends Omit<SchemaClosureContext, 'resolveRef'> {
+  readonly resolveRef?: (refPath: readonly string[], context: SchemaClosureResolutionContext) => SchemaRefResolution | PromiseLike<SchemaRefResolution>;
+}
+/** Context supplied while the host resolves one ref during closure loading. */
+interface SchemaClosureResolutionContext {
+  readonly path: readonly (string | number)[];
+  readonly refPath: readonly string[];
+  readonly ref: SchemaRefNode;
+  readonly depth: number;
+}
+/** Load references using a synchronous host resolver. */
+declare function resolveSchemaReferences(entry: unknown, context?: SchemaClosureContext): SchemaClosureResult;
+/** Load references using a synchronous or asynchronous host resolver. */
+declare function resolveSchemaReferencesAsync(entry: unknown, context?: AsyncSchemaClosureContext): Promise<SchemaClosureResult>;
+/** Resolve all external schema refs reachable from an operation declaration. */
+declare function resolveOperationClosure(entry: OperationDefinition, context?: SchemaClosureContext): SchemaClosureResult;
+declare function resolveOperationClosureAsync(entry: OperationDefinition, context?: AsyncSchemaClosureContext): Promise<SchemaClosureResult>;
+//#endregion
+export { SchemaClosureResolutionContext as a, SchemaRefResolution as c, resolveSchemaReferences as d, resolveSchemaReferencesAsync as f, SchemaClosureDiagnostic as i, resolveOperationClosure as l, ResolvedSchemaGraph as n, SchemaClosureResult as o, SchemaClosureContext as r, SchemaClosureStatus as s, AsyncSchemaClosureContext as t, resolveOperationClosureAsync as u };

package/dist/index-BGz7L_Fq.d.cts

@@ -0,0 +1,73 @@
+import { L as SchemaTypeTerm, ct as SchemaNode, ht as SchemaRefEntry, y as SchemaTypeExpr } from "./index-i7Au-FQ6.cjs";
+import { d as RelationResult, i as RelationContext } from "./index-ba_52Yu9.cjs";
+
+//#region src/type-interpreter/interpreter.d.ts
+type TypeInterpreterPath = readonly (string | number)[];
+interface TypeInterpreterDiagnostic {
+  readonly code: string;
+  readonly path: TypeInterpreterPath;
+  readonly message: string;
+}
+type TypeInterpreterStatus = 'evaluated' | 'incomplete' | 'rejected';
+type EvaluatedTypeTerm = SchemaNode | SchemaTypeExpr;
+type TypeInterpreterResult = {
+  readonly status: 'evaluated';
+  readonly term: EvaluatedTypeTerm;
+  readonly schema?: SchemaNode;
+  readonly unresolvedTypeVars?: readonly string[];
+  readonly issues: readonly TypeInterpreterDiagnostic[];
+} | {
+  readonly status: 'incomplete';
+  readonly issues: readonly TypeInterpreterDiagnostic[];
+} | {
+  readonly status: 'rejected';
+  readonly issues: readonly TypeInterpreterDiagnostic[];
+};
+interface TypeInterpreterContext {
+  readonly typeVars?: Readonly<Record<string, SchemaTypeTerm>>;
+  readonly refs?: readonly SchemaRefEntry[];
+  readonly maxDepth?: number;
+  readonly maxSteps?: number;
+}
+declare function evaluateExpression(term: unknown, context?: TypeInterpreterContext): TypeInterpreterResult;
+declare const evaluateSchemaTypeTerm: typeof evaluateExpression;
+//#endregion
+//#region src/type-interpreter/term-relation.d.ts
+interface TypeTermRelationContext {
+  readonly interpreter?: TypeInterpreterContext;
+  readonly relation?: RelationContext;
+  readonly hostTypeRelation?: (sourcePath: readonly string[], targetPath: readonly string[]) => HostTypeRelationDecision;
+}
+type HostTypeRelationDecision = boolean | {
+  readonly status: 'assignable' | 'incompatible' | 'unknown' | 'unsupported';
+  readonly message?: string;
+};
+declare function checkTypeTermRelation(source: SchemaTypeTerm, target: SchemaTypeTerm, context?: TypeTermRelationContext): RelationResult;
+//#endregion
+//#region src/type-interpreter/type-variable-solver.d.ts
+interface TypeVariableConstraint {
+  readonly source: SchemaTypeTerm;
+  readonly target: SchemaTypeTerm;
+}
+interface TypeVariableSolverInput {
+  readonly variables: readonly string[];
+  readonly constraints: readonly TypeVariableConstraint[];
+}
+interface TypeVariableSolverIssue {
+  readonly code: string;
+  readonly constraint?: number;
+  readonly variable?: string;
+  readonly message: string;
+}
+interface TypeVariableSolverResult {
+  readonly status: 'solved' | 'unknown' | 'incompatible' | 'rejected';
+  readonly bindings: Readonly<Record<string, EvaluatedTypeTerm>>;
+  readonly unresolved: readonly string[];
+  readonly issues: readonly TypeVariableSolverIssue[];
+}
+interface TypeVariableSolverContext extends TypeTermRelationContext {
+  readonly interpreter?: TypeInterpreterContext;
+}
+declare function solveTypeVariables(input: TypeVariableSolverInput, context?: TypeVariableSolverContext): TypeVariableSolverResult;
+//#endregion
+export { evaluateSchemaTypeTerm as _, TypeVariableSolverResult as a, TypeTermRelationContext as c, TypeInterpreterContext as d, TypeInterpreterDiagnostic as f, evaluateExpression as g, TypeInterpreterStatus as h, TypeVariableSolverIssue as i, checkTypeTermRelation as l, TypeInterpreterResult as m, TypeVariableSolverContext as n, solveTypeVariables as o, TypeInterpreterPath as p, TypeVariableSolverInput as r, HostTypeRelationDecision as s, TypeVariableConstraint as t, EvaluatedTypeTerm as u };