@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/directValues.d.ts

@@ -1,8 +1,12 @@
 import type { DirectOperationContract, DirectMessageRoot } from './directOperation.js';
 import type { DirectDirection, DirectScalarDuty, DirectStructuralMatch } from './directStructure.js';
-import type { DirectRootPlan } from './directStructurePlan.js';
+import type { DirectRootPlan, DirectProjectionPlan } from './directStructurePlan.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ElementNode } from './canonicalGraph.js';
+import type { ProjectionStructuralMatch } from './directStructure.js';
 import type { ResolverUsage } from './semanticBudget.js';
 import type { SyntaxElement } from '../loader/orderedSyntax.js';
+import type { ApplicationGroupsOptions, ApplicationGroupPlan } from './applicationGroups.js';
 export type DirectPrimitive = string | boolean | number;
 /** Inverse construction caps; XML encoding may impose smaller byte/text/node limits. */
 export declare const DIRECT_VALUE_LIMITS: Readonly<{
@@ -11,7 +15,10 @@ export declare const DIRECT_VALUE_LIMITS: Readonly<{
 }>;
 export declare const DIRECT_VALUE_VERSION = "direct-values-v1";
 export declare const DIRECT_SCALAR_POLICY = "direct-string-boolean-int-v1";
-export type DirectApplicationValue = DirectPrimitive | Readonly<Record<string, DirectPrimitive | readonly DirectPrimitive[]>>;
+export interface DirectRecordValue {
+    readonly [key: string]: DirectApplicationValue | readonly DirectApplicationValue[];
+}
+export type DirectApplicationValue = DirectPrimitive | DirectRecordValue | readonly DirectApplicationValue[];
 export interface DirectValueMapping extends DirectRootPlan {
     readonly kind: 'direct-mapping';
     readonly version: typeof DIRECT_VALUE_VERSION;
@@ -21,10 +28,19 @@ export interface DirectValueMapping extends DirectRootPlan {
     readonly contextId: string;
     readonly usage: ResolverUsage;
 }
+export interface ComponentValueMapping {
+    readonly kind: 'component-mapping';
+    readonly version: 'component-values-v1';
+    readonly admitted: false;
+    readonly root: DirectMessageRoot;
+    readonly direction: DirectDirection;
+    readonly contextId: string;
+    readonly usage: ResolverUsage;
+}
 export interface DirectAssessedScalar extends DirectScalarDuty {
     readonly normalized: string;
     readonly canonical: string;
-    readonly value: DirectPrimitive;
+    readonly value: DirectPrimitive | readonly DirectPrimitive[];
 }
 export interface DirectValueReceipt {
     readonly kind: 'direct-value';
@@ -44,6 +60,25 @@ export interface DirectExpandedValue {
     readonly validated: DirectValueReceipt;
     readonly usage: ResolverUsage;
 }
+export interface ProjectionValueReceipt {
+    readonly kind: 'projection-value';
+    readonly scope: 'direct-structure-and-scalars';
+    readonly admitted: false;
+    readonly root: ElementNode;
+    readonly structural: ProjectionStructuralMatch;
+    readonly contextId: string;
+    readonly operands: readonly DirectAssessedScalar[];
+    readonly value: DirectApplicationValue;
+    readonly usage: ResolverUsage;
+}
+export interface ProjectionExpandedValue {
+    readonly kind: 'projection-expanded';
+    readonly provenance: 'generated-direct-value';
+    readonly admitted: false;
+    readonly payload: SyntaxElement;
+    readonly validated: ProjectionValueReceipt;
+    readonly usage: ResolverUsage;
+}
 export interface DirectValueFailure {
     readonly kind: 'scalar-invalid' | 'value-invalid' | 'unsupported' | 'cancelled' | 'resource-limit';
     readonly rule: string;
@@ -56,14 +91,38 @@ type Options = Readonly<{
     maxText?: number;
     maxItems?: number;
 }>;
+/** Inspect only the exact context-issued expansion; no operation or portable authority is conferred. */
+export declare function inspectProjectionExpandedValue(value: unknown, context: SemanticContext): ProjectionExpandedValue;
+/** Context-owned value evidence does not authenticate an operation, portable bundle or runtime admission. */
+export declare function inspectProjectionValue(value: unknown, context: SemanticContext): ProjectionValueReceipt;
 /** Inspection is identity-only; operational consumers still check native authority and limits. */
 export declare function inspectDirectValueMapping(mapping: unknown, contract: DirectOperationContract): DirectValueMapping;
 export declare function inspectDirectValue(value: unknown, contract: DirectOperationContract): DirectValueReceipt;
 export declare function inspectDirectExpandedValue(value: unknown, contract: DirectOperationContract): DirectExpandedValue;
 /** Includes absent optional/zero-count slots; no observed payload is needed. */
 export declare function createDirectValueMapping(contract: DirectOperationContract, direction: DirectDirection, options?: Options): DirectValueMapping | DirectValueFailure;
+/** Plan an operation direction through the existing native structured owner without flattening or preview admission.
+ * @remarks This transient mapping carries a distinct version and retains the exact native projection privately.
+ *   It grants no codec, artifact or transport authority; copied mappings and mappings for other operations refuse.
+ * @returns An operation-owned structured mapping or the existing unsupported/cancellation/resource diagnostic.
+ */
+export declare function createComponentValueMapping(contract: DirectOperationContract, direction: DirectDirection, options?: Options, applicationGroups?: ApplicationGroupsOptions): ComponentValueMapping | DirectValueFailure;
+/** Reconstruct another operation direction using the exact issued presentation, without payload configuration.
+ * @returns A fresh source-owned mapping retaining request-selected naming options, or a native refusal.
+ * @throws TypeError For foreign/copy-shaped input mappings or malformed presentation options.
+ */
+export declare function createComponentDirectionalMapping(contract: DirectOperationContract, supplied: unknown, direction: DirectDirection, options?: Options): ComponentValueMapping | DirectValueFailure;
+/** Authenticate the exact structured mapping and expose its existing native plan to local consumers only. */
+export declare function inspectComponentValueMapping(value: unknown, contract: DirectOperationContract): Readonly<{
+    mapping: ComponentValueMapping;
+    projection: DirectProjectionPlan;
+    applicationGroups?: ApplicationGroupPlan;
+}>;
+/** Validate scalar operands and retain nested application records without claiming source or operation admission. */
+export declare function assessProjectionScalars(context: SemanticContext, supplied: unknown, options?: Options, mapping?: ComponentValueMapping): ProjectionValueReceipt | DirectValueFailure;
 export declare function assessDirectScalars(contract: DirectOperationContract, match: unknown, options?: Options): DirectValueReceipt | DirectValueFailure;
+/** Validate structured application values with the same native structural/scalar owners, without operation admission. */
+export declare function expandProjectionValue(context: SemanticContext, root: ElementNode, application: unknown, options?: Options, mapping?: ComponentValueMapping): ProjectionExpandedValue | DirectValueFailure;
 /** Pure shape validation plus lexical reconstruction, followed by existing validators. */
 export declare function expandDirectValue(contract: DirectOperationContract, suppliedMapping: unknown, application: unknown, options?: Options): DirectExpandedValue | DirectValueFailure;
 export {};
-//# sourceMappingURL=directValues.d.ts.map