@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/scalarSchemaAssessment.d.ts

@@ -0,0 +1,424 @@
+import type { SemanticTypeReference as Reference, SemanticTypeDependency } from './semanticTypeReference.js';
+import type { GraphNode, LexicalValue, NodeId, ValueConstraint } from "./canonicalGraph.js";
+import type { ScalarFacet as Facet } from "./schemaSimpleTypeProperties.js";
+import type { AssessmentContext } from "./schemaScalarContext.js";
+import type { SchemaOperand } from "./schemaDatatypeValues.js";
+import type { SchemaPattern } from "./schemaPattern.js";
+import type { ExpandedName } from '../loader/orderedSyntax.js';
+export type ScalarEnforcement = "lexical-space" | "enumeration" | "pattern" | "whitespace" | "numeric-bounds" | "numeric-precision" | "length" | "QName-context" | "default-fixed" | "list" | "union";
+export type ScalarConstraintLayer = Readonly<{
+    owner: NodeId;
+    facets: readonly Facet[];
+    patterns: readonly SchemaPattern[];
+}>;
+export type ScalarObligation = Readonly<{
+    rule: "simple-content-base-mixed-emptiable" | "raw-simple-content-derivation-validity" | "raw-simple-facet-restriction-validity" | "raw-simple-target-namespace";
+    component: NodeId;
+    contextId?: string;
+}>;
+export type ScalarSupportPlan = Readonly<{
+    obligations?: readonly ScalarObligation[];
+    id: NodeId;
+    reference: Reference;
+    variety: "atomic" | "list" | "union";
+    primitive?: string;
+    builtin?: string;
+    item?: Reference;
+    members?: readonly Reference[];
+    layers: readonly ScalarConstraintLayer[];
+    declaredMembers?: readonly Reference[];
+    unionMapping?: "xsd10-flattened";
+    whitespace: "preserve" | "replace" | "collapse" | "member";
+    enforcement: readonly ScalarEnforcement[];
+    runtimeOwner: "#184";
+    consumers: readonly ["#188", "#189", "#198"];
+}>;
+/** Unary CURRENT image decision, not private-alias tuple feasibility.
+ * An empty image does not rule out inherited exclusive-endpoint repeats.
+ * The enclosing scalar receipt retains all pending formation obligations.
+ */
+export type PrivateAliasEndpointAdmission = Readonly<{
+    scope: 'current-atomic-admission';
+    family: string;
+}> & (Readonly<{
+    kind: 'empty-current-admission';
+}> | Readonly<{
+    kind: 'admitted-witness';
+    operand: SchemaOperand;
+    membershipWord: LexicalValue;
+    primitiveWord: LexicalValue;
+    primitive: Reference;
+}>);
+export type EndpointTupleTerm = Readonly<{
+    kind: 'role' | 'constant';
+    index: number;
+}>;
+/** A finite Boolean circuit in topological order; an empty circuit means true. */
+export type EndpointTupleFormula = readonly (Readonly<{
+    kind: 'same-value';
+    left: EndpointTupleTerm;
+    right: EndpointTupleTerm;
+}> | Readonly<{
+    kind: 'order';
+    left: EndpointTupleTerm;
+    right: EndpointTupleTerm;
+    outcome: 'less' | 'equal' | 'greater' | 'undefined';
+}> | Readonly<{
+    kind: 'and' | 'or';
+    operands: readonly number[];
+}> | Readonly<{
+    kind: 'not';
+    operand: number;
+}>)[];
+export type PrivateAliasEndpointTupleInput = Readonly<{
+    roles: readonly Readonly<{
+        type: Reference;
+        exclusiveRepeat?: 'minExclusive' | 'maxExclusive';
+    }>[];
+    constants: readonly Readonly<{
+        type: Reference;
+        lexical: LexicalValue;
+    }>[];
+    formula: EndpointTupleFormula;
+}>;
+export type PrivateAliasEndpointChoice = Readonly<{
+    type: Reference;
+    operand: SchemaOperand;
+    primitive: Reference;
+    primitiveWord: LexicalValue;
+}> & (Readonly<{
+    branch: Readonly<{
+        kind: 'current';
+    }>;
+    membershipWord: LexicalValue;
+}> | Readonly<{
+    branch: Readonly<{
+        kind: 'exclusive-repeat';
+        component: number;
+        bound: 'minExclusive' | 'maxExclusive';
+    }>;
+    membershipWord?: never;
+}>);
+/** Exact finite-role fragment, not the full shared digit-track tuple theorem. */
+export type PrivateAliasEndpointTuples = Readonly<{
+    scope: 'current-enumeration-or-singleton-endpoint-tuples-v1';
+}> & (Readonly<{
+    kind: 'empty-endpoint-tuples';
+}> | Readonly<{
+    kind: 'endpoint-tuple';
+    roles: readonly PrivateAliasEndpointChoice[];
+}>);
+/** Fixed, genuinely formed programmes in one current context; no unknown image labels. */
+export type RegularBinaryWordView = Readonly<{
+    type: Reference;
+    context: LexicalValue['context'];
+    root?: Readonly<{
+        type: Reference;
+        lexical: LexicalValue;
+    }>;
+}>;
+export type RegularBinaryWordViews = Readonly<{
+    scope: 'regular-atomic-binary-word-views-v1';
+    excluded: readonly ['LIST', 'duration', 'numeric-guards', 'whole-value-image-labels'];
+}> & (Readonly<{
+    kind: 'empty-word-views';
+}> | Readonly<{
+    kind: 'word-views';
+    core: string;
+    binary: SchemaOperand;
+    views: readonly Readonly<{
+        type: Reference;
+        lexical: LexicalValue;
+        operand: SchemaOperand;
+    }>[];
+}>);
+/** A saved-map label denotes membership in a genuinely formed finite LIST image. */
+export type FiniteImageBinaryWordView = RegularBinaryWordView & Readonly<{
+    labels: readonly Readonly<{
+        image: Reference;
+        context: LexicalValue['context'];
+        positive: boolean;
+    }>[];
+}>;
+export type FiniteImageBinaryWordViews = Readonly<{
+    scope: 'finite-image-binary-word-views-v1';
+    excluded: readonly ['nonfinite-image-labels', 'duration-P-blocks', 'nonregular-numeric-joins'];
+}> & (Readonly<{
+    kind: 'empty-word-views';
+}> | Readonly<{
+    kind: 'word-views';
+    core: string;
+    binary: SchemaOperand;
+    views: readonly Readonly<{
+        type: Reference;
+        lexical: LexicalValue;
+        operand: SchemaOperand;
+        labels: readonly Readonly<{
+            image: Reference;
+            positive: boolean;
+            inverseWord?: LexicalValue;
+        }>[];
+    }>[];
+}>);
+/** References in this view select scalar content, including the private scalar
+ * of a complex source owner. They are not synthetic GraphNode references.
+ * Fundamental-facet equality follows equal complete determining properties;
+ * this view does not publish unevaluated cardinality/finiteness values.
+ */
+export type ScalarContentProperties = Readonly<{
+    definition: string;
+    name?: ExpandedName;
+    targetNamespace: string;
+    final: readonly string[];
+    base?: Reference;
+    variety: 'atomic' | 'list' | 'union' | 'absent';
+    primitive?: string;
+    item?: Reference;
+    members?: readonly Reference[];
+    generatedPolicy?: 'GSC1';
+    annotation: 'absent' | 'source';
+}>;
+/** Opaque internal evidence; its data is never accepted from a caller. */
+export type ScalarFacetEvidence = Readonly<{
+    kind: 'scalar-facet-evidence';
+}>;
+export type ScalarFacetAnnotationPresence = 'absent' | 'present' | 'unresolved';
+export type OriginalScalarFacetRecipe = Readonly<{
+    kind: 'original-scalar-facet-recipe';
+}>;
+export declare function scalarSchemaAssessment(c: AssessmentContext, options?: {
+    schemaOperandsOnly?: boolean;
+    originalRecipe?: (type: Reference, owner: GraphNode) => OriginalScalarFacetRecipe;
+    originalFacet?: (type: Reference, lexical: LexicalValue, owner: NodeId) => {
+        operand: SchemaOperand;
+        obligations: readonly ScalarObligation[];
+        typeDependencies: readonly SemanticTypeDependency[];
+    };
+}): {
+    finiteImageBinaryWordViews: (views: readonly FiniteImageBinaryWordView[], owner: GraphNode) => FiniteImageBinaryWordViews;
+    regularBinaryWordViews: (views: readonly RegularBinaryWordView[], owner: GraphNode) => RegularBinaryWordViews;
+    privateAliasEndpointAdmission: (reference: Reference, owner: GraphNode) => PrivateAliasEndpointAdmission;
+    privateAliasEndpointTuples: (input: PrivateAliasEndpointTupleInput, owner: GraphNode) => PrivateAliasEndpointTuples;
+    privateAliasEndpointWordCapacity: (reference: Reference, owner: GraphNode) => {
+        inventory: {
+            ordinal: number;
+            kind: string;
+            fixed: readonly boolean[];
+            annotation: ScalarFacetAnnotationPresence;
+        }[];
+        maskAuthority: "current-atomic-admission";
+        kind: "finite-capacity";
+        family: string;
+        roles: number;
+        formulaLeaves: number;
+        maskStates: number;
+        constants: number;
+        equations: number;
+        tracks: number;
+        fieldStates: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        jointStates: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        encodedTuple: import("./schemaEndpointWordCapacity.js").EndpointCapacityExpression;
+        maximumWordUnits?: undefined;
+        encodedTupleUnits?: undefined;
+    } | {
+        kind: "finite-ieee-capacity";
+        family: string;
+        roles: number;
+        maximumWordUnits: number;
+        encodedTupleUnits: number;
+        inventory: {
+            ordinal: number;
+            kind: string;
+            fixed: readonly boolean[];
+            annotation: ScalarFacetAnnotationPresence;
+        }[];
+        maskAuthority: "current-ieee-spelling-and-finite-inverse";
+    };
+    typeDependencies: (reference: Reference, owner: GraphNode) => readonly Readonly<{
+        contextId: string;
+        type: import("./semanticTypeReference.js").SemanticTypeIdentity;
+    }>[];
+    ensure: (reference: Reference, owner: GraphNode) => Readonly<{
+        obligations?: readonly ScalarObligation[];
+        id: NodeId;
+        reference: Reference;
+        variety: "atomic" | "list" | "union";
+        primitive?: string;
+        builtin?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        layers: readonly ScalarConstraintLayer[];
+        declaredMembers?: readonly Reference[];
+        unionMapping?: "xsd10-flattened";
+        whitespace: "preserve" | "replace" | "collapse" | "member";
+        enforcement: readonly ScalarEnforcement[];
+        runtimeOwner: "#184";
+        consumers: readonly ["#188", "#189", "#198"];
+    }>;
+    checkFinal: (base: Reference, method: string, owner: GraphNode) => void;
+    checkValue: (reference: Reference, constraint: ValueConstraint, owner: GraphNode) => {
+        enforcement: ScalarEnforcement[];
+        obligations?: readonly ScalarObligation[];
+        id: NodeId;
+        reference: Reference;
+        variety: "atomic" | "list" | "union";
+        primitive?: string;
+        builtin?: string;
+        item?: Reference;
+        members?: readonly Reference[];
+        layers: readonly ScalarConstraintLayer[];
+        declaredMembers?: readonly Reference[];
+        unionMapping?: "xsd10-flattened";
+        whitespace: "preserve" | "replace" | "collapse" | "member";
+        runtimeOwner: "#184";
+        consumers: readonly ["#188", "#189", "#198"];
+    };
+    assessConstraint: (reference: Reference, constraint: ValueConstraint, owner: GraphNode) => {
+        value: Readonly<{
+            family: string;
+            canonical: string;
+            length?: string;
+            decimal?: import("./datatypeValues.js").DecimalOperand;
+            ordered?: readonly import("./datatypeValues.js").DecimalOperand[];
+            zoned?: boolean;
+            normalized?: string;
+            calendar?: import("./schemaExactCalendar.js").Calendar;
+            duration?: import("./schemaExactCalendar.js").Duration;
+            items?: readonly SchemaOperand[];
+            selectedMembers?: readonly Reference[];
+        }>;
+        plan: {
+            enforcement: ScalarEnforcement[];
+            obligations?: readonly ScalarObligation[];
+            id: NodeId;
+            reference: Reference;
+            variety: "atomic" | "list" | "union";
+            primitive?: string;
+            builtin?: string;
+            item?: Reference;
+            members?: readonly Reference[];
+            layers: readonly ScalarConstraintLayer[];
+            declaredMembers?: readonly Reference[];
+            unionMapping?: "xsd10-flattened";
+            whitespace: "preserve" | "replace" | "collapse" | "member";
+            runtimeOwner: "#184";
+            consumers: readonly ["#188", "#189", "#198"];
+        };
+    };
+    equivalent: (referenceA: Reference, a: LexicalValue, referenceB: Reference, b: LexicalValue, owner: GraphNode) => boolean;
+    contentIdentity: (reference: Reference, owner: GraphNode) => {
+        definition: string;
+        reference?: Reference;
+    };
+    contentProperties: (reference: Reference, owner: GraphNode) => ScalarContentProperties;
+    readOriginalRecipe: (reference: Reference, owner: GraphNode) => OriginalScalarFacetRecipe;
+    contentDerivation: (derived: Reference, base: Reference, owner: GraphNode) => boolean;
+    facetPropertiesEquivalent: (a: Reference, b: Reference, owner: GraphNode) => boolean;
+    readFacetProperties: (reference: Reference, owner: GraphNode) => {
+        evidence: ScalarFacetEvidence;
+        obligations: readonly ScalarObligation[];
+        annotations: ScalarFacetAnnotationPresence;
+        typeDependencies: readonly SemanticTypeDependency[];
+    };
+    compareFacetProperties: (a: ScalarFacetEvidence, b: ScalarFacetEvidence, owner: GraphNode) => boolean;
+    compareFacetAnnotations: (a: ScalarFacetEvidence, b: ScalarFacetEvidence, owner?: GraphNode) => "equal" | "different" | "unresolved";
+    selectOperand: (reference: Reference, owner: GraphNode) => void;
+    assess: (reference: Reference, lexical: LexicalValue, owner: GraphNode) => Readonly<{
+        family: string;
+        canonical: string;
+        length?: string;
+        decimal?: import("./datatypeValues.js").DecimalOperand;
+        ordered?: readonly import("./datatypeValues.js").DecimalOperand[];
+        zoned?: boolean;
+        normalized?: string;
+        calendar?: import("./schemaExactCalendar.js").Calendar;
+        duration?: import("./schemaExactCalendar.js").Duration;
+        items?: readonly SchemaOperand[];
+        selectedMembers?: readonly Reference[];
+    }>;
+    compare: (a: Readonly<{
+        family: string;
+        canonical: string;
+        length?: string;
+        decimal?: Readonly<{
+            coefficient: bigint;
+            scale: number;
+            digits?: number;
+        }>;
+        ordered?: readonly Readonly<{
+            coefficient: bigint;
+            scale: number;
+            digits?: number;
+        }>[];
+        zoned?: boolean;
+        normalized?: string;
+        calendar?: Readonly<{
+            family: import("./schemaExactCalendar.js").CalendarFamily;
+            year: bigint;
+            month: number;
+            day: number;
+            seconds: Readonly<{
+                coefficient: bigint;
+                scale: number;
+                digits: number;
+            }>;
+            zoned: boolean;
+            lexical: string;
+            digits: number;
+        }>;
+        duration?: Readonly<{
+            months: bigint;
+            seconds: Readonly<{
+                coefficient: bigint;
+                scale: number;
+                digits: number;
+            }>;
+            digits: number;
+            lexical: string;
+        }>;
+        items?: readonly Readonly</*elided*/ any>[];
+        selectedMembers?: readonly Reference[];
+    }>, b: Readonly<{
+        family: string;
+        canonical: string;
+        length?: string;
+        decimal?: Readonly<{
+            coefficient: bigint;
+            scale: number;
+            digits?: number;
+        }>;
+        ordered?: readonly Readonly<{
+            coefficient: bigint;
+            scale: number;
+            digits?: number;
+        }>[];
+        zoned?: boolean;
+        normalized?: string;
+        calendar?: Readonly<{
+            family: import("./schemaExactCalendar.js").CalendarFamily;
+            year: bigint;
+            month: number;
+            day: number;
+            seconds: Readonly<{
+                coefficient: bigint;
+                scale: number;
+                digits: number;
+            }>;
+            zoned: boolean;
+            lexical: string;
+            digits: number;
+        }>;
+        duration?: Readonly<{
+            months: bigint;
+            seconds: Readonly<{
+                coefficient: bigint;
+                scale: number;
+                digits: number;
+            }>;
+            digits: number;
+            lexical: string;
+        }>;
+        items?: readonly Readonly</*elided*/ any>[];
+        selectedMembers?: readonly Reference[];
+    }>, owner: GraphNode | undefined) => number | undefined;
+};