@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/directOperation.js

@@ -1,18 +1,30 @@
 import { directLimit, directLoadingLimits } from './directExecutionPolicy.js';
 /** Transient source-owned schema selection. This module grants no runtime admission. */
 import { loadSemanticSchemaInput } from '../loader/schemaInput.js';
-import { SchemaLoadingError, WSDL_NAMESPACE, syntaxAttribute, syntaxElements, isXmlNCName } from '../loader/orderedSyntax.js';
+import { SchemaLoadingError, WSDL_NAMESPACE, XSD_NAMESPACE, syntaxAttribute, syntaxElements, isXmlNCName } from '../loader/orderedSyntax.js';
 import { globalId } from './canonicalGraph.js';
 import { createApplicationBudget, DEFAULT_MAX_NODES } from './semanticBudget.js';
 import { qualifyDirectSource } from './checkedSourcePreparation.js';
+import { qualifyComponentSource, inspectComponentSourceQualification } from './checkedComponentSource.js';
+import { prepareWsdlPolicyRequirements, assertWsdlPolicyRequirements } from './wsdlPolicyRequirements.js';
 const SOAP = 'http://schemas.xmlsoap.org/wsdl/soap/';
 const HTTP = 'http://schemas.xmlsoap.org/soap/http';
+const ADDRESSING_WSDL = 'http://www.w3.org/2006/05/addressing/wsdl';
+/** Distinguish typed RPC parameters without inventing a document element.
+ * @param root Selected native message.
+ * @returns Whether the message uses the bounded RPC profile.
+ */
+export function isRpcMessageRoot(root) {
+    return 'kind' in root && root.kind === 'rpc-typed-parts-v1';
+}
 const issued = new WeakMap();
 /** Object identity authenticates the exact issued roots; context IDs and digests do not. */
 export function inspectDirectOperation(contract, expectedContext) {
     const owned = issued.get(contract);
     if (!owned || expectedContext !== undefined && owned.context !== expectedContext)
         throw new TypeError('Unauthenticated or foreign direct operation');
+    if (owned.policyOwner)
+        assertWsdlPolicyRequirements(owned.source, owned.policyOwner);
     return owned;
 }
 class Refusal extends Error {
@@ -32,10 +44,47 @@ export async function selectDirectOperation(source, selector, options) {
 }
 /** Private-module composition seam: portable reading and selection share one request. */
 export async function selectDirectOperationInRequest(source, selector, options, budget) {
+    return selectOperationInRequest(source, selector, options, budget, 'direct');
+}
+/** Select through additive native component qualification without granting codec, transport or runtime admission.
+ * @remarks The same WSDL binding/message owner is used by the existing preview. New contracts carry a distinct
+ *   basis and correspondence; preview codecs and source capsules continue to refuse them until independently extended.
+ * @returns Fresh source-bound operation roots or an explicit qualification/selection failure.
+ */
+export async function selectComponentOperation(source, selector, options) {
+    return selectComponentOperationInRequest(source, selector, options, createApplicationBudget(options.limits));
+}
+/** Private composition seam: artifact reading and fresh component selection share the same sticky request. */
+export async function selectComponentOperationInRequest(source, selector, options, budget) {
+    return selectOperationInRequest(source, selector, { ...options, standardLibraries: Object.freeze([...(options.standardLibraries ?? [])]) }, budget, 'components');
+}
+/** Select requested service operations against one fresh native source snapshot and sticky request.
+ * @remarks Native whole-source qualification is reused by identity within this batch only. Every binding/message
+ *   selection still runs through the same owner; no source flags, saved reports or operation-name guesses are consumed.
+ * @returns One result in each requested position, including explicit refusals. No requested operation is omitted.
+ */
+export async function selectComponentOperations(source, selectors, options) {
+    const budget = createApplicationBudget(options.limits), cache = {};
+    const owned = budget.snapshot(selectors);
+    if (!Array.isArray(owned) || Object.keys(owned).length !== owned.length)
+        throw new TypeError('Dense operation selectors required');
+    const results = [];
+    const captured = { ...options, standardLibraries: Object.freeze([...(options.standardLibraries ?? [])]) };
+    for (const selector of owned)
+        results.push(await selectOperationInRequest(source, selector, captured, budget, 'components', cache));
+    return Object.freeze(results);
+}
+async function selectOperationInRequest(source, selector, options, budget, profile, cache) {
     const check = () => { if (options.signal?.aborted)
         throw new Cancelled(); budget.chargeWork(); };
     const refuse = (kind, rule) => { throw new Refusal(kind, rule); };
     const failure = (kind, rule) => Object.freeze({ kind, rule, usage: Object.freeze({ ...budget.usage() }) });
+    const sourceFailure = (kind, rule) => {
+        const result = failure(kind, rule);
+        if (cache && result.kind !== 'selected')
+            cache.failure = result;
+        return result;
+    };
     try {
         // Fixed terminal envelope and issuance bookkeeping, before any source work.
         budget.chargeWork(4096);
@@ -44,20 +93,43 @@ export async function selectDirectOperationInRequest(source, selector, options,
         const name = (value) => value && typeof value.namespace === 'string' && typeof value.local === 'string' && isXmlNCName(value.local);
         if (!name(ownedSelector.portType) || !name(ownedSelector.binding) || typeof ownedSelector.operation !== 'string' || !isXmlNCName(ownedSelector.operation))
             return failure('selection-refused', 'explicit-selector');
-        const input = await loadSemanticSchemaInput(source, { ...options.loading, limits: directLoadingLimits(budget, options.loading.limits), signal: options.signal, chargeWork: amount => { check(); budget.chargeWork(amount); } });
+        if (cache?.failure)
+            return failure(cache.failure.kind, cache.failure.rule);
+        const input = cache?.input ?? await loadSemanticSchemaInput(source, { ...options.loading, limits: directLoadingLimits(budget, options.loading.limits), signal: options.signal, chargeWork: amount => { check(); budget.chargeWork(amount); } });
+        if (cache)
+            cache.input = input;
         check();
         const result = budget.guard(() => {
-            const qualified = qualifyDirectSource(input, { budget, maxNodes: options.limits?.maxNodes ?? directLimit(budget, DEFAULT_MAX_NODES), check });
+            const qualificationOptions = { budget, maxNodes: options.limits?.maxNodes ?? directLimit(budget, DEFAULT_MAX_NODES), check };
+            const qualified = cache?.qualified ?? (profile === 'direct' ? qualifyDirectSource(input, qualificationOptions)
+                : qualifyComponentSource(input, { ...qualificationOptions, standardLibraries: options.standardLibraries }));
             if (qualified.kind === 'resource-limit')
-                return failure('resource-limit', 'source-qualification');
+                return sourceFailure('resource-limit', 'source-qualification');
             if (qualified.kind === 'source-preparation-failed' && qualified.category === 'resource-limit')
-                return failure('resource-limit', 'source-preparation');
-            if (qualified.kind !== 'qualified-source')
-                return failure(qualified.kind === 'source-preparation-failed' && qualified.category === 'invalid-schema' ? 'invalid-schema' : 'inconclusive', 'source-preparation');
-            if (!qualified.eligible)
-                return failure(qualified.localDisproved || qualified.closure.kind === 'invalid-schema' ? 'invalid-schema' : 'inconclusive', 'whole-source-qualification');
-            const { request } = qualified;
+                return sourceFailure('resource-limit', 'source-preparation');
+            if (qualified.kind !== 'qualified-source' && qualified.kind !== 'component-source')
+                return sourceFailure(qualified.kind === 'source-preparation-failed' && qualified.category === 'invalid-schema' ? 'invalid-schema' : 'inconclusive', 'source-preparation');
+            if (qualified.kind === 'component-source')
+                inspectComponentSourceQualification(qualified, input);
+            const construction = qualified.kind === 'component-source' ? qualified.construction : qualified;
+            const eligible = qualified.kind === 'component-source' ? qualified.schemaEligible : qualified.eligible;
+            if (!eligible)
+                return sourceFailure(construction.localDisproved || construction.closure.kind === 'invalid-schema' ? 'invalid-schema' : 'inconclusive', qualified.kind === 'component-source' && qualified.correspondence.kind === 'inconclusive-correspondence'
+                    ? `whole-source-qualification:${qualified.correspondence.rule}${qualified.correspondence.path ? ':' + qualified.correspondence.path : ''}` : 'whole-source-qualification');
+            const { request } = construction;
             const context = request.actual;
+            let policyOwner;
+            if (profile === 'components') {
+                const policies = cache?.policy ?? prepareWsdlPolicyRequirements(input, budget, check);
+                if (policies.kind !== 'wsdl-policy-requirements')
+                    return sourceFailure(policies.kind, 'rule' in policies ? policies.rule : 'policy-budget');
+                assertWsdlPolicyRequirements(input, policies);
+                policyOwner = policies;
+                if (cache && qualified.kind === 'component-source') {
+                    cache.qualified = qualified;
+                    cache.policy = policies;
+                }
+            }
             const children = (node) => {
                 check();
                 budget.chargeWork(128 + node.children.length * 16 + node.attributes.length * 32);
@@ -70,6 +142,15 @@ export async function selectDirectOperationInRequest(source, selector, options,
                 return syntaxElements(node);
             };
             const attr = syntaxAttribute;
+            const addressingMessages = new Set();
+            if (profile === 'components')
+                for (const document of input.documents) {
+                    for (const portType of children(document.root).filter(node => node.name.namespace === WSDL_NAMESPACE && node.name.local === 'portType'))
+                        for (const operation of children(portType).filter(node => node.name.namespace === WSDL_NAMESPACE && node.name.local === 'operation'))
+                            for (const message of children(operation).filter(node => node.name.namespace === WSDL_NAMESPACE && ['input', 'output', 'fault'].includes(node.name.local)))
+                                addressingMessages.add(message);
+                }
+            const addressingAttribute = (node, namespace, local) => addressingMessages.has(node) && namespace === ADDRESSING_WSDL && local === 'Action';
             const exactly = (node, namespace, local) => {
                 const found = children(node).filter(c => c.name.namespace === namespace && c.name.local === local);
                 if (found.length !== 1)
@@ -78,7 +159,8 @@ export async function selectDirectOperationInRequest(source, selector, options,
             };
             const shape = (node, allowed) => {
                 for (const child of children(node))
-                    if (!allowed.includes(`${child.name.namespace}#${child.name.local}`))
+                    if (!allowed.includes(`${child.name.namespace}#${child.name.local}`)
+                        && !policyOwner?.isPolicyMetadata(child))
                         refuse('unsupported', 'binding-child-shape');
                 for (const child of node.children) {
                     if (child.kind !== 'text')
@@ -93,7 +175,8 @@ export async function selectDirectOperationInRequest(source, selector, options,
             const attrs = (node, allowed) => {
                 children(node);
                 for (const a of node.attributes)
-                    if (a.name.namespace !== '' || !allowed.includes(a.name.local))
+                    if (!addressingAttribute(node, a.name.namespace, a.name.local)
+                        && (a.name.namespace !== '' || !allowed.includes(a.name.local)))
                         refuse('unsupported', 'binding-attribute-shape');
             };
             // Conservative extension policy: only known WSDL 1.1/SOAP 1.1 syntax, even when optional.
@@ -105,7 +188,7 @@ export async function selectDirectOperationInRequest(source, selector, options,
                 portType: ['name'], operation: ['name', 'parameterOrder'], input: ['name', 'message'], output: ['name', 'message'], fault: ['name', 'message'],
                 binding: ['name', 'type'], service: ['name'], port: ['name', 'binding'],
             };
-            const soapAttributes = { binding: ['style', 'transport'], operation: ['soapAction', 'style'], body: ['use', 'parts'], fault: ['name', 'use'], address: ['location'] };
+            const soapAttributes = { binding: ['style', 'transport'], operation: ['soapAction', 'style'], body: profile === 'components' ? ['use', 'parts', 'namespace', 'encodingStyle'] : ['use', 'parts'], fault: ['name', 'use'], address: ['location'] };
             for (const document of input.documents) {
                 const stack = [document.root];
                 while (stack.length) {
@@ -113,12 +196,18 @@ export async function selectDirectOperationInRequest(source, selector, options,
                     const nested = children(node);
                     if (qualifiedSchemas.has(node))
                         continue;
+                    if (policyOwner?.isPolicyMetadata(node))
+                        continue;
                     if (node.name.namespace === WSDL_NAMESPACE && node.name.local === 'documentation')
                         continue;
                     const allowed = node.name.namespace === WSDL_NAMESPACE ? attributes[node.name.local] : node.name.namespace === SOAP ? soapAttributes[node.name.local] : undefined;
                     if (!allowed)
                         return refuse('unsupported', 'wsdl-extension');
                     for (const a of node.attributes) {
+                        // @why The May 2006 WSDL binding assigns no normative intent to Action without UsingAddressing.
+                        //   UsingAddressing remains unsupported, so these attributes are retained metadata, never SOAP header instructions.
+                        if (addressingAttribute(node, a.name.namespace, a.name.local))
+                            continue;
                         if (a.name.namespace === WSDL_NAMESPACE && a.name.local === 'required' && node.name.namespace === SOAP && ['true', '1', 'false', '0'].includes(a.value))
                             continue;
                         if (a.name.namespace !== '' || !allowed.includes(a.name.local))
@@ -174,7 +263,8 @@ export async function selectDirectOperationInRequest(source, selector, options,
                 return refuse('unsupported', 'soap-binding-style');
             if (attr(soapBinding, 'transport') !== HTTP)
                 return refuse('unsupported', 'soap-transport');
-            if ((attr(soapOperation, 'style') ?? attr(soapBinding, 'style') ?? 'document') !== 'document')
+            const style = attr(soapOperation, 'style') ?? attr(soapBinding, 'style') ?? 'document';
+            if (style !== 'document' && !(profile === 'components' && style === 'rpc'))
                 return refuse('unsupported', 'soap-style');
             const action = attr(soapOperation, 'soapAction');
             if (action === undefined)
@@ -201,6 +291,7 @@ export async function selectDirectOperationInRequest(source, selector, options,
                 shape(boundSyntax, [soap(faultName === undefined ? 'body' : 'fault'), ws('documentation')]);
                 const body = exactly(boundSyntax, SOAP, faultName === undefined ? 'body' : 'fault');
                 shape(body, []);
+                attrs(body, faultName === undefined ? ['use', 'parts'] : ['use', 'name']);
                 if (attr(body, 'use') !== 'literal')
                     return refuse('unsupported', 'literal-required');
                 if (faultName !== undefined && attr(body, 'name') !== faultName)
@@ -227,17 +318,61 @@ export async function selectDirectOperationInRequest(source, selector, options,
                     return refuse('selection-refused', 'element-type');
                 return Object.freeze({ message: message.name, part: partName, element, type: element.type, source: part.source });
             };
+            const rpcRoot = (messageSyntax, boundSyntax, direction) => {
+                attrs(messageSyntax, ['name', 'message']);
+                attrs(boundSyntax, ['name']);
+                shape(messageSyntax, [ws('documentation')]);
+                shape(boundSyntax, [soap('body'), ws('documentation')]);
+                const body = exactly(boundSyntax, SOAP, 'body');
+                shape(body, []);
+                const encoding = 'http://schemas.xmlsoap.org/soap/encoding/';
+                if (attr(body, 'use') !== 'encoded' || attr(body, 'encodingStyle')?.trim() !== encoding)
+                    return refuse('unsupported', 'rpc-string-encoding');
+                const bodyNamespace = attr(body, 'namespace');
+                if (!bodyNamespace || !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(bodyNamespace))
+                    return refuse('unsupported', 'rpc-body-namespace');
+                const message = reference(portType, messageSyntax, 'message');
+                if (message.kind !== 'wsdl' || message.role !== 'message')
+                    return refuse('selection-refused', 'message-reference');
+                shape(message.syntax, [ws('part'), ws('documentation')]);
+                const declared = children(message.syntax).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'part');
+                if (!declared.length || direction === 'output' && declared.length !== 1)
+                    return refuse('unsupported', 'rpc-single-string-result');
+                const names = new Set();
+                const parts = declared.map(part => {
+                    attrs(part, ['name', 'type']);
+                    shape(part, [ws('documentation')]);
+                    const name = attr(part, 'name');
+                    if (!name || !isXmlNCName(name) || names.has(name))
+                        return refuse('selection-refused', 'rpc-part-name');
+                    names.add(name);
+                    const path = part.source.path.slice(message.syntax.source.path.length) || '/';
+                    const refs = message.references.filter(r => r.path === path && r.attribute === 'type');
+                    if (refs.length !== 1)
+                        return refuse('unsupported', 'rpc-part-type-required');
+                    const resolved = context.resolve(refs[0].reference);
+                    if (direction === 'output' && (resolved.kind !== 'builtin' || resolved.name.namespace !== XSD_NAMESPACE || resolved.name.local !== 'string'))
+                        return refuse('unsupported', 'rpc-string-part-required');
+                    return Object.freeze({ name, type: refs[0].reference, source: part.source });
+                });
+                if (attr(body, 'parts') !== undefined && attr(body, 'parts').trim().split(/[\t\r\n ]+/).join(' ') !== parts.map(p => p.name).join(' '))
+                    return refuse('unsupported', 'rpc-body-parts');
+                return Object.freeze({ kind: 'rpc-typed-parts-v1', message: message.name, parts, bodyNamespace, encoding,
+                    wrapper: { namespace: bodyNamespace, local: ownedSelector.operation + (direction === 'output' ? 'Response' : '') }, source: body.source });
+            };
             const io = (direction, declaration) => {
                 const boundIo = exactly(bound, WSDL_NAMESPACE, direction);
                 const boundName = attr(boundIo, 'name');
                 const expectedName = attr(declaration, 'name') ?? `${ownedSelector.operation}${direction === 'input' ? 'Request' : 'Response'}`;
                 if (boundName !== undefined && boundName !== expectedName)
                     return refuse('selection-refused', 'binding-message-name');
-                return root(declaration, boundIo);
+                return style === 'rpc' ? rpcRoot(declaration, boundIo, direction) : root(declaration, boundIo);
             };
             const requestRoot = io('input', abstractInput), responseRoot = io('output', abstractOutput);
             const declaredFaults = children(abstract).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'fault');
             const boundFaults = children(bound).filter(c => c.name.namespace === WSDL_NAMESPACE && c.name.local === 'fault');
+            if (style === 'rpc' && (declaredFaults.length || boundFaults.length))
+                return refuse('unsupported', 'rpc-declared-fault');
             if (declaredFaults.length !== boundFaults.length)
                 return refuse('selection-refused', 'fault-mapping');
             const faultNames = new Set();
@@ -255,15 +390,25 @@ export async function selectDirectOperationInRequest(source, selector, options,
             });
             check();
             // Charge publication traversal before retaining authority. Roots stay exact context objects.
-            const contract = { selector: ownedSelector, contextId: context.contextId, basis: 'native-direct-premises-v1', correspondence: 'dated-XSD-2004-direct-v1',
-                binding: { version: '1.1', style: 'document', use: 'literal', transport: HTTP, action, source: binding.context.source },
+            const contract = { selector: ownedSelector, contextId: context.contextId,
+                basis: profile === 'direct' ? 'native-direct-premises-v1' : 'native-component-premises-v1',
+                correspondence: profile === 'direct' ? 'dated-XSD-2004-direct-v1' : 'dated-XSD-2004-components-v1',
+                binding: { version: '1.1', style: style, use: style === 'rpc' ? 'encoded' : 'literal',
+                    ...(style === 'rpc' ? { encoding: 'http://schemas.xmlsoap.org/soap/encoding/' } : {}), transport: HTTP, action, source: binding.context.source },
                 input: requestRoot, output: responseRoot, faults,
-                missingCapabilities: ['matcher', 'projection', 'scalar-payload', 'bundle', 'codec', 'buffered-transport', 'structured-generation'], admitted: false };
+                ...(policyOwner ? { policy: policyOwner.forBinding(binding.syntax), addressingActions: { required: false,
+                        input: attr(abstractInput, 'Action', ADDRESSING_WSDL), output: attr(abstractOutput, 'Action', ADDRESSING_WSDL),
+                        faults: declaredFaults.flatMap(fault => {
+                            const action = attr(fault, 'Action', ADDRESSING_WSDL);
+                            return action === undefined ? [] : [{ name: attr(fault, 'name'), action }];
+                        }) } } : {}),
+                missingCapabilities: ['matcher', 'projection', 'scalar-payload', 'bundle', 'codec', 'buffered-transport', 'structured-generation',
+                    ...(policyOwner?.forBinding(binding.syntax).kind === 'https-transport' ? ['policy-enforcement'] : [])], admitted: false };
             budget.freeze(contract);
             check();
             budget.chargeWork(256);
             const selected = Object.freeze({ kind: 'selected', contract, usage: Object.freeze({ ...budget.usage() }) });
-            issued.set(contract, Object.freeze({ contract, context, source: input, evidence: qualified }));
+            issued.set(contract, Object.freeze({ contract, context, source: input, evidence: qualified, ...(policyOwner ? { policyOwner } : {}) }));
             return selected;
         });
         return result.kind === 'resource-limit' ? failure('resource-limit', 'request-budget') : result;

package/dist/compiler/directSoap.d.ts

@@ -1,7 +1,8 @@
 import type { DirectOperationContract } from './directOperation.js';
-import type { DirectCodecFailure, DirectDecodedXml, DirectXmlLimits } from './directCodec.js';
+import type { DirectCodecFailure, DirectDecodedXml, ComponentDecodedXml, DirectXmlLimits } from './directCodec.js';
 import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
 import type { ResolverUsage } from './semanticBudget.js';
+import type { ComponentRecordProjection, ComponentRecordDecodedXml } from './componentRecordProjection.js';
 export interface DirectSoapOptions {
     readonly service: ExpandedName;
     readonly port: string;
@@ -18,11 +19,12 @@ export interface DirectSoapFailure {
     readonly kind: DirectCodecFailure['kind'] | 'transport' | 'protocol';
     readonly rule: string;
     readonly usage: ResolverUsage;
+    readonly phase?: 'input' | 'response';
 }
-export type DirectSoapResult = DirectSoapFailure | Readonly<{
+type SoapResult<D> = DirectSoapFailure | Readonly<{
     kind: 'soap-response' | 'soap-fault';
     admitted: false;
-    decoded: DirectDecodedXml;
+    decoded: D;
     /** Actual bounded HTTP entity bytes, before any decoding; caller-owned data. */
     responseBytes: Uint8Array;
     status: number;
@@ -33,10 +35,32 @@ export type DirectSoapResult = DirectSoapFailure | Readonly<{
         string: string;
         actor?: string;
     }>;
+    /** Qualified optional response blocks ignored under SOAP 1.1; their application semantics were not assessed. */
+    ignoredHeaders?: readonly ExpandedName[];
     usage: ResolverUsage;
 }>;
+export type DirectSoapResult = SoapResult<DirectDecodedXml>;
+export type ComponentSoapResult = SoapResult<ComponentDecodedXml>;
+export type ComponentRecordSoapResult = SoapResult<ComponentDecodedXml | ComponentRecordDecodedXml>;
+export interface ComponentSoapOptions extends Omit<DirectSoapOptions, 'endpoint' | 'allowEndpoint'> {
+    readonly endpoint?: string;
+    /** Optional restriction; omission permits only the configured or selected address. */
+    readonly allowEndpoint?: (endpoint: URL) => boolean;
+    /** Additional caller-owned PEM trust anchor; certificate and hostname verification remain enabled. */
+    readonly ca?: string;
+}
 /** Shared entry guard: consumers must call before reading any SOAP option. */
-export declare function directSoapOptionsShape(options: unknown, check: () => void): string | undefined;
+export declare function directSoapOptionsShape(options: unknown, check: () => void, additional?: readonly string[]): string | undefined;
 /** Authentication and fresh-value validation precede dependency bootstrap and all HTTP I/O. */
 export declare function exchangeDirectSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: DirectSoapOptions): Promise<DirectSoapResult>;
-//# sourceMappingURL=directSoap.d.ts.map
+/** Execute one authenticated component mapping through the existing SOAP client and native XML checks.
+ * @remarks HTTPS transport with verified server identity is supported. Client certificates, timestamps and
+ *   timestamp layouts refuse before I/O. Algorithm suites constrain WS-Security cryptographic operations;
+ *   this fragment has no supporting tokens, signature or encryption operations and emits no security header.
+ *   Optional caller restrictions narrow the selected/configured endpoint. No gateway or source admission is granted here.
+ * @returns A validated response/fault or explicit failure, with owned work and connections closed.
+ * @throws TypeError For foreign native handles. Invalid explicit timer/XML capacities throw RangeError.
+ */
+export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions): Promise<ComponentSoapResult>;
+export declare function exchangeComponentSoap(contract: DirectOperationContract, inputMapping: unknown, application: unknown, options: ComponentSoapOptions, responseProjection: ComponentRecordProjection): Promise<ComponentRecordSoapResult>;
+export {};