@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/directValues.d.ts

@@ -0,0 +1,128 @@
+import type { DirectOperationContract, DirectMessageRoot } from './directOperation.js';
+import type { DirectDirection, DirectScalarDuty, DirectStructuralMatch } from './directStructure.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<{
+    maxText: number;
+    maxItems: 100000;
+}>;
+export declare const DIRECT_VALUE_VERSION = "direct-values-v1";
+export declare const DIRECT_SCALAR_POLICY = "direct-string-boolean-int-v1";
+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;
+    readonly admitted: false;
+    readonly root: DirectMessageRoot;
+    readonly direction: DirectDirection;
+    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 DirectPrimitive[];
+}
+export interface DirectValueReceipt {
+    readonly kind: 'direct-value';
+    readonly scope: 'direct-structure-and-scalars';
+    readonly admitted: false;
+    readonly mapping: DirectValueMapping;
+    readonly structural: DirectStructuralMatch;
+    readonly operands: readonly DirectAssessedScalar[];
+    readonly value: DirectApplicationValue;
+    readonly usage: ResolverUsage;
+}
+export interface DirectExpandedValue {
+    readonly kind: 'direct-expanded';
+    readonly provenance: 'generated-direct-value';
+    readonly admitted: false;
+    readonly payload: SyntaxElement;
+    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;
+    readonly schemaPath?: string;
+    readonly payloadPath?: string;
+    readonly usage: ResolverUsage;
+}
+type Options = Readonly<{
+    signal?: AbortSignal;
+    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 {};