@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/finiteRe01Verification.d.ts

@@ -0,0 +1,218 @@
+/** Complete verification of supplied finite evidence, never universal witness search. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { ComponentConstructionReceipt, ConstructionObligation, SimpleRestrictionPredicate } from './schemaConstructionAssessment.js';
+import type { CorrespondenceReceipt, CorrespondenceFailure, AdditiveSimplePropertyReceipt } from './re01CandidateCorrespondence.js';
+import { RE01_DERIVATION_DOMAIN } from './re01TypeProperties.js';
+import type { SchemaNotationProperties } from './schemaNotationProperties.js';
+import type { GeneratedScalarResult } from './schemaScalarKernel.js';
+import type { SemanticTypeDependency, SemanticTypeReference } from './semanticTypeReference.js';
+import type { IdentityConstraintReceipt } from './schemaIdentityConstraints.js';
+export type FiniteScalarSlotReceipt = Extract<GeneratedScalarResult, {
+    kind: 'checked';
+}>;
+export type FiniteRe01EvidenceNode = Readonly<{
+    id: string;
+    parent: SemanticContext;
+    context: SemanticContext;
+    target: NodeId;
+    intermediate: NodeId;
+    ancestor: SemanticTypeReference;
+    /** References to concrete evidence for generated hypothetical RE01 premises. */
+    premises: readonly string[];
+}>;
+export type FiniteRe01Evidence = Readonly<{
+    root: string;
+    nodes: readonly FiniteRe01EvidenceNode[];
+}>;
+/** The existing primitive identity rule needs no hypothetical endpoint. */
+export type FiniteRe01PrimitiveEvidence = Readonly<{
+    root: Readonly<{
+        kind: 'primitive-no-change';
+    }>;
+    /** Supplied constructions for any other nonprimitive actual obligations. */
+    nodes: readonly FiniteRe01EvidenceNode[];
+}>;
+export type FiniteVerificationFailure = CorrespondenceFailure & Readonly<{
+    contextId?: string;
+}>;
+export type FiniteNotationReceipt = Readonly<{
+    contextId: string;
+    properties: SchemaNotationProperties;
+    origin: 'original' | 'addition';
+}>;
+export type FiniteProofStep = Readonly<{
+    evidence: string;
+    parentContext: string;
+    contextId: string;
+    target: NodeId;
+    correspondence: CorrespondenceReceipt;
+    components: readonly ComponentConstructionReceipt[];
+    scalarSlots: readonly FiniteScalarSlotReceipt[];
+    notations: readonly FiniteNotationReceipt[];
+    identityConstraints: readonly IdentityConstraintReceipt[];
+    premises: readonly string[];
+    primitiveNoChange: readonly NodeId[];
+}>;
+export type FiniteCandidateReceipt = Readonly<{
+    kind: 'checked-candidate';
+    authority: 'RE01-finite-evidence-v1';
+    domain: typeof RE01_DERIVATION_DOMAIN;
+    scope: 'supplied-construction-and-finite-evidence';
+    actualContextId: string;
+    target: NodeId;
+    root: string;
+    actualComponents: readonly ComponentConstructionReceipt[];
+    actualPrimitiveNoChange: readonly NodeId[];
+    actualScalarSlots: readonly FiniteScalarSlotReceipt[];
+    actualNotations: readonly FiniteNotationReceipt[];
+    actualIdentityConstraints: readonly IdentityConstraintReceipt[];
+    proof: readonly FiniteProofStep[];
+    claims: Readonly<{
+        actualObligations: 'checked';
+        suppliedCandidate: 'checked';
+        universalCoverage: false;
+        completeNegativeAnswer: false;
+        searchTermination: false;
+    }>;
+}>;
+export type FiniteVerificationResult = FiniteCandidateReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+export type FinitePrimitiveReceipt = Omit<FiniteCandidateReceipt, 'kind' | 'scope' | 'root' | 'claims'> & Readonly<{
+    kind: 'checked-primitive';
+    scope: 'primitive-no-change-and-finite-evidence';
+    root: 'primitive-no-change';
+    claims: Readonly<{
+        actualObligations: 'checked';
+        primitiveTarget: 'checked';
+        universalCoverage: false;
+        completeNegativeAnswer: false;
+        searchTermination: false;
+    }>;
+}>;
+export type FinitePrimitiveVerificationResult = FinitePrimitiveReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+/** A requirement inspection is not a successful finite witness. */
+export type FiniteRe01Frontier = Readonly<{
+    kind: 'inspected-frontier';
+    context: SemanticContext;
+    requirements: readonly Readonly<{
+        target: NodeId;
+        ancestor: SemanticTypeReference;
+        primitive: boolean;
+    }>[];
+    components: readonly ComponentConstructionReceipt[];
+    scalarSlots: readonly FiniteScalarSlotReceipt[];
+    notations: readonly FiniteNotationReceipt[];
+    identityConstraints: readonly IdentityConstraintReceipt[];
+    correspondence?: CorrespondenceReceipt;
+    deferred: readonly Readonly<{
+        context: SemanticContext;
+        obligation: ConstructionObligation;
+    }>[];
+    typeDependencies: readonly Readonly<{
+        from: SemanticContext;
+        dependency: SemanticTypeDependency;
+    }>[];
+}>;
+export type FiniteRe01Hypothesis = Omit<FiniteRe01EvidenceNode, 'id' | 'premises'>;
+export type FiniteRe01FrontierResult = FiniteRe01Frontier | FiniteVerificationFailure | ResourceLimitFailure;
+export type FiniteRe01FrontierSession = Readonly<{
+    kind: 'native-frontier-session';
+    actual: FiniteRe01Frontier;
+    inspectCandidate(hypothesis: FiniteRe01Hypothesis): FiniteRe01FrontierResult;
+}>;
+export declare function assertFiniteRe01Frontier(context: SemanticContext, frontier: FiniteRe01Frontier): void;
+/** Internal native collection authority shared by supplied verification and research construction. */
+export declare function prepareFiniteRe01Frontier(actual: SemanticContext): FiniteRe01FrontierSession | FiniteVerificationFailure | ResourceLimitFailure;
+export declare function assertFiniteCandidateReceipt(actual: SemanticContext, receipt: FiniteCandidateReceipt): void;
+export declare function assertFinitePrimitiveReceipt(actual: SemanticContext, receipt: FinitePrimitiveReceipt): void;
+/** Inspect the exact checked contexts in proof order; diagnostic context IDs never reconstruct authority. */
+export declare function inspectFiniteProofContexts(actual: SemanticContext, receipt: FiniteCandidateReceipt | FinitePrimitiveReceipt): readonly SemanticContext[];
+export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence): FiniteVerificationResult;
+export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01PrimitiveEvidence): FinitePrimitiveVerificationResult;
+export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence | FiniteRe01PrimitiveEvidence): FiniteVerificationResult | FinitePrimitiveVerificationResult;
+/** Reuse native actual preparation within one authenticated research request. */
+export declare function verifyFiniteRe01EvidenceWithFrontier(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence | FiniteRe01PrimitiveEvidence, prepared?: FiniteRe01FrontierSession): FiniteVerificationResult | FinitePrimitiveVerificationResult;
+/** Product direct strategy: no hypothetical candidates and no search-negative claim. */
+export declare function verifyDirectActualSchema(actual: SemanticContext): Readonly<{
+    kind: 'checked-direct' | 'inconclusive-direct';
+    frontier: FiniteRe01Frontier;
+    unresolved: readonly NodeId[];
+}> | FiniteVerificationFailure | ResourceLimitFailure;
+export type ExtensionChainReceipt = Readonly<{
+    kind: 'checked-extension-chain' | 'inconclusive-extension-chain';
+    basis: 'XSD-2004-extension-only-ancestry';
+    frontier: FiniteRe01Frontier;
+    extensionOnly: readonly NodeId[];
+    unresolved: readonly NodeId[];
+}>;
+/** Authenticate actual-only extension ancestry; saved or copied receipt fields grant no authority. */
+export declare function assertExtensionChainReceipt(actual: SemanticContext, receipt: ExtensionChainReceipt): void;
+/** Close actual RE01 duties whose ancestry has no restriction after the designated ancestor.
+ * @remarks The 2004 Structures cos-ct-extends.1.5 note identifies this sufficient case as trivial.
+ *   All component premises and aggregate dependencies are still checked by the existing native owner.
+ *   No candidate context, endpoint replacement or primitive relabelling is used. The existing direct preview is unchanged.
+ * @returns Authenticated actual-only closure, an unresolved duty inventory, or the native failure.
+ * @throws TypeError For a non-actual context. Explicit request exhaustion remains sticky.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-ct-extends
+ */
+export declare function verifyExtensionChainActualSchema(actual: SemanticContext): ExtensionChainReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+export type AdditiveLocalClosureReceipt = Readonly<{
+    kind: 'checked-additive-local-closure';
+    actual: FiniteRe01Frontier;
+    frontier: FiniteRe01Frontier;
+    target: NodeId;
+    intermediate: NodeId;
+    representative: NodeId;
+    nativeProperties?: AdditiveSimplePropertyReceipt;
+    targetCorrespondence: 'unassessed';
+    actualRe01: 'unassessed';
+    admitted: false;
+}>;
+/** Authenticate the exact native local closure; neither target correspondence nor actual RE01 is asserted. */
+export declare function assertAdditiveLocalClosure(actual: SemanticContext, receipt: AdditiveLocalClosureReceipt): void;
+/** Check fresh extension/restriction representatives and their complete native dependencies without endpoint shadowing.
+ * @remarks Every original component and scope owner remains unchanged. This establishes local construction and
+ *   aggregate discharge only; the representative-to-target correspondence and actual RE01 remain unassessed.
+ * @returns An authenticated local closure or explicit native unavailability/resource failure; never admission.
+ */
+export declare function verifyAdditiveRestrictionLocalClosure(actual: SemanticContext, target: NodeId): AdditiveLocalClosureReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+export type AdditiveSimplePredicateReceipt = Readonly<{
+    kind: 'checked-additive-simple-predicate';
+    actual: FiniteRe01Frontier;
+    frontier: FiniteRe01Frontier;
+    target: NodeId;
+    intermediate: NodeId;
+    predicate: SimpleRestrictionPredicate;
+    actualRe01: 'unassessed';
+    datedInterpretation: 'unassessed';
+    admitted: false;
+}>;
+export type SimpleExtensionConstructionReceipt = Readonly<{
+    kind: 'checked-simple-extension-construction' | 'inconclusive-simple-extension-construction';
+    basis: 'XSD-2004-simple-extension-spine';
+    complex: ExtensionChainReceipt;
+    simple: readonly AdditiveSimplePredicateReceipt[];
+    unresolved: readonly NodeId[];
+    datedInterpretation: 'unassessed';
+    admitted: false;
+}>;
+/** Authenticate the complete native premises; saved fields grant neither source nor runtime admission. */
+export declare function assertSimpleExtensionConstruction(actual: SemanticContext, receipt: SimpleExtensionConstructionReceipt): void;
+/** Check the sufficient simple-content extension spine and its original-target alternative restriction.
+ * @remarks Complex ancestry must consist solely of simple-content extensions and terminate at a simple type.
+ *   The designated ancestor is exactly anySimpleType; its fresh extension is independently constructed and
+ *   all original target restriction predicates and aggregate dependencies pass without replacing original bindings.
+ *   This collects native premises; the dated in-principle interpretation remains a separate qualification duty.
+ * @returns Authenticated premises or unresolved targets/native failure, never admission or a general negative answer.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-ct-extends
+ */
+export declare function verifySimpleExtensionConstruction(actual: SemanticContext): SimpleExtensionConstructionReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+/** Authenticate the actual-target predicate and fresh-middle closure; this grants no dated or runtime admission. */
+export declare function assertAdditiveSimplePredicate(actual: SemanticContext, receipt: AdditiveSimplePredicateReceipt): void;
+/** Close a fresh middle and evaluate the original target's simple restriction predicate without a renamed representative.
+ * @remarks All original bindings are preserved and all consumed native dependencies are aggregated. The standards
+ *   interpretation of the alternative derivation remains unassessed; this is not actual RE01 or source eligibility.
+ * @returns A fresh native paired predicate/closure or explicit unavailability/resource failure.
+ */
+export declare function verifyAdditiveSimplePredicate(actual: SemanticContext, target: NodeId): AdditiveSimplePredicateReceipt | FiniteVerificationFailure | ResourceLimitFailure;