@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/directStructurePlan.d.ts

@@ -1,8 +1,11 @@
 /** Single native direct slot interpretation shared by matching and value mapping. */
 import type { DirectMessageRoot } from './directOperation.js';
 import type { SemanticContext } from './semanticContext.js';
-import type { ElementNode, ParticleNode } from './canonicalGraph.js';
+import type { AttributeNode, ComplexTypeNode, ElementNode, GraphNode, NodeId, ParticleNode, Reference } from './canonicalGraph.js';
 import type { ExpandedName } from '../loader/orderedSyntax.js';
+import type { ProjectionScalarList } from './projectionScalar.js';
+import type { SemanticParticle, SemanticParticleView } from './particleSemanticView.js';
+import type { AttributeWildcard } from './schemaAttributeUses.js';
 export interface DirectSlot {
     readonly element: ElementNode;
     readonly particle: ParticleNode;
@@ -12,5 +15,144 @@ export interface DirectRootPlan {
     readonly rootBuiltin?: ExpandedName;
     readonly slots: readonly DirectSlot[];
 }
+export type DirectProjectionValue = Readonly<({
+    kind: 'scalar';
+    builtin: ExpandedName;
+    declared?: true;
+    retainLexical?: true;
+    list?: ProjectionScalarList;
+} | {
+    kind: 'record';
+    type: NodeId;
+}) & {
+    nillable?: true;
+    constraint?: Readonly<{
+        kind: 'fixed' | 'default';
+        lexical: string;
+        canonical: string;
+    }>;
+}>;
+export interface DirectProjectionSlot {
+    readonly element: ElementNode;
+    readonly particle: ParticleNode;
+    readonly value: DirectProjectionValue;
+}
+export interface DirectProjectionAttribute {
+    readonly bag?: true;
+    readonly declaration: AttributeNode;
+    readonly required: boolean;
+    readonly builtin: ExpandedName;
+    readonly constraint?: Readonly<{
+        kind: 'fixed' | 'default';
+        lexical: string;
+        canonical: string;
+    }>;
+    readonly retainLexical?: true;
+    readonly list?: ProjectionScalarList;
+}
+export interface DirectProjectionRecord {
+    readonly type: ComplexTypeNode;
+    readonly slots: readonly DirectProjectionSlot[];
+    readonly attributes: readonly DirectProjectionAttribute[];
+    readonly content: 'empty' | 'element-only' | 'simple' | 'mixed';
+    readonly text?: Extract<DirectProjectionValue, {
+        kind: 'scalar';
+    }>;
+    readonly keyed?: true;
+    readonly fixedOrder?: true;
+    readonly contextual?: true;
+    readonly attributeWildcard?: AttributeWildcard;
+    readonly ordered?: true;
+}
+export type DirectProjectionSelection = DirectProjectionSlot | Readonly<{
+    kind: 'wildcard';
+    element?: ElementNode;
+    particle: ParticleNode;
+}>;
+/** Inspect source particles only after authenticating their projection owner. */
+export declare function inspectProjectionGrammar(context: SemanticContext, record: DirectProjectionRecord): Readonly<{
+    view: SemanticParticleView;
+    first(particle: SemanticParticle): readonly string[];
+    bodyNullable(particle: SemanticParticle): boolean;
+    slot(key: string): DirectProjectionSlot | undefined;
+}> | undefined;
+/** Match ordered children using authenticated native particles, without granting source or operation admission.
+ * @constraints Leaf alphabets must be disjoint; native strict/lax/skip policy selects declaration assessment or unassessed preservation.
+ * @returns Source-owned slots in document order, or undefined when the child sequence is outside the particle language.
+ * @throws TypeError For an unauthenticated record or foreign context.
+ */
+export declare function matchOrderedProjection(context: SemanticContext, record: DirectProjectionRecord, names: readonly ExpandedName[], check: () => void): readonly DirectProjectionSelection[] | undefined;
+/** Resolve a policy-assessed wildcard declaration, never from a caller-supplied type or companion-name guess.
+ * @returns The source declaration, or undefined for an excluded namespace, missing declaration or incomplete universe.
+ * @throws TypeError For copied/foreign projection records.
+ */
+export declare function resolveProjectionWildcard(context: SemanticContext, record: DirectProjectionRecord, name: ExpandedName, check: () => void): ElementNode | undefined;
+/** Select native application wildcard policy from the authenticated particle, without payload-driven schema acquisition.
+ * @param context Exact source context owning the record.
+ * @param record Authenticated projection record.
+ * @param name Actual expanded payload identity.
+ * @param check Budget and cancellation checkpoint.
+ * @returns Declaration assessment, an unassessed native policy selection, or no match.
+ * @throws TypeError For a foreign or copied record.
+ */
+export declare function selectProjectionWildcard(context: SemanticContext, record: DirectProjectionRecord, name: ExpandedName, check: () => void): Readonly<{
+    element?: ElementNode;
+}> | undefined;
+export interface DirectProjectionPlan {
+    readonly root: DirectProjectionValue;
+    readonly records: readonly DirectProjectionRecord[];
+}
+/** Inspect wildcard presence on an exact ordered plan; this describes existing grammar, never adds admission. */
+export declare function inspectOrderedProjectionWildcards(context: SemanticContext, record: DirectProjectionRecord): boolean;
+/** Inspect whether every wildcard on an authenticated ordered record requires unassessed preservation. */
+export declare function inspectUnassessedProjectionWildcards(context: SemanticContext, record: DirectProjectionRecord): boolean;
+/** Capability diagnostic only; this record neither proves schema invalidity nor grants admission. */
+export interface DirectProjectionUnavailable {
+    readonly rule: string;
+    readonly component: NodeId;
+    readonly schemaPath: string;
+}
+/** JSON representation policy only; native datatype calculations decide lexical/value validity. */
+export declare function projectionScalarRepresentation(name: ExpandedName): 'string' | 'number' | 'boolean' | undefined;
+/** Test projected XML 1.0 character data without interpreting lexical application strings. */
+export declare const isXmlCharacters: (value: string) => boolean;
+/** Check a projected Namespaces 1.0 binding; the empty key denotes the default namespace. */
+export declare const isXmlNamespaceBinding: (prefix: string, namespace: string) => boolean;
+/** Resolve and plan an application attribute permitted by the source wildcard.
+ * @param context Exact source context.
+ * @param record Source-derived record containing the native attribute policy.
+ * @param name Expanded payload attribute identity.
+ * @param check Budget and cancellation checkpoint.
+ * @param unsupported Existing diagnostic owner for unavailable native scalar duties.
+ * @returns A typed declaration, unassessed lexical selection, or no policy match.
+ * @throws TypeError For a non-actual context.
+ */
+export declare function selectProjectionAttribute(context: SemanticContext, record: DirectProjectionRecord, name: ExpandedName, check: () => void, unsupported: () => never): Readonly<{
+    attribute?: DirectProjectionAttribute;
+}> | undefined;
+/**
+ * Derive record structure using native component identity, including anonymous scopes and recursion.
+ * @remarks This is a projection plan, not source validity, correspondence or runtime admission.
+ *   Effective sequences and known attributes of explicitly represented builtin scalars are supported.
+ *   Exact numeric families and temporal/binary values use strings; QName and document-wide ID/ENTITY duties are outside this plan.
+ *   Inheritance is read from native content and attribute owners; only unit sequence groups flatten into peer properties.
+ *   Other represented particles retain ordered children in $content; disjoint element/wildcard alphabets are required.
+ *   Source-selected keyed content and attribute fallback preserve mixed text and local-name collisions.
+ *   Native wildcard policies select known declaration duties or lexical preservation; retained scopes propagate through known intermediates.
+ *   Native default/fixed values are explicit XML-assessment augmentation, never a missing required application field.
+ *   The checked-direct preview adapter below retains its flat-only grammar.
+ */
+export declare function planDirectProjection(context: SemanticContext, root: ElementNode, check: () => void, unsupported: (detail?: DirectProjectionUnavailable) => never): DirectProjectionPlan;
+/** Plan a source-owned type using native scalar, content and particle owners.
+ * @param context Native source context.
+ * @param owner Exact source graph node owning the type reference.
+ * @param reference Selected source type.
+ * @param check Cooperative checkpoint.
+ * @param unsupported Explicit refusal callback.
+ * @returns The same native projection used by document elements, without element facts.
+ */
+export declare function planProjectionType(context: SemanticContext, owner: GraphNode, reference: Reference, check: () => void, unsupported: (detail?: DirectProjectionUnavailable) => never): DirectProjectionPlan;
+/** Adapt the native projection to the supported flat preview without widening admission. */
 export declare function planDirectRoot(context: SemanticContext, root: DirectMessageRoot, check: () => void, unsupported: () => never): DirectRootPlan;
-//# sourceMappingURL=directStructurePlan.d.ts.map
+/** Flat-only projection adapter; its input is derived data, never native admission. */
+export declare function flatDirectProjection(plan: DirectProjectionPlan, check: () => void, unsupported: () => never): DirectRootPlan;