@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/schemaTemporalAliases.js

@@ -0,0 +1,195 @@
+/** Complete fixed-value calendar aliases under the accepted DT A coordinates. */
+import { showInstant } from './schemaExactCalendar.js';
+export function* calendarAliasExpressions(calendar, owner, c) {
+    const budget = { charge: work => c.step(owner, work), text: text => { c.text(text, owner); },
+        arithmetic: digits => c.step(owner, (digits + 2) ** 2) };
+    const value = calendar.seconds;
+    budget.arithmetic(value.digits + value.scale + 4);
+    const power = 10n ** BigInt(value.scale);
+    const shifted = (seconds) => {
+        budget.arithmetic(value.digits + value.scale + 8);
+        c.step(owner, 4);
+        return { ...value, coefficient: value.coefficient + BigInt(seconds) * power };
+    };
+    const quote = (text) => {
+        c.text(text, owner);
+        c.step(owner, text.length * 2 + 1);
+        return text.replace(/[\\.\-^?*+{}()\[\]|]/g, '\\$&');
+    };
+    const two = (value) => { c.step(owner, 4); return value.toString().padStart(2, '0'); };
+    const offsets = function* () {
+        yield 0;
+        if (calendar.zoned)
+            for (let minute = 1; minute <= 840; minute++) {
+                c.step(owner, 2);
+                yield minute;
+                yield -minute;
+            }
+    };
+    const expression = (instant, zone, second60 = false, hour24 = false) => {
+        c.text(instant, owner);
+        c.step(owner, instant.length * 3 + 12);
+        const match = /^(-?[0-9]+)-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]+))?Z$/.exec(instant);
+        const [, year, month, day, h, m, s, fraction = ''] = match;
+        const hour = hour24 ? '24' : h, second = second60 ? '60' : s;
+        const suffix = fraction ? '[.]' + fraction + '0*' : '([.]0+)?';
+        const clock = hour + ':' + m + ':' + second;
+        const zeroClock = h === '00' && m === '00' && s === '00' && !fraction;
+        let text;
+        switch (calendar.family) {
+            case 'dateTime':
+                text = quote(year + '-' + month + '-' + day + 'T' + clock) + suffix;
+                break;
+            case 'time':
+                text = quote(clock) + suffix;
+                break;
+            case 'date':
+                if (!zeroClock)
+                    return undefined;
+                text = quote(year + '-' + month + '-' + day);
+                break;
+            case 'gYear':
+                if (!zeroClock || month !== '01' || day !== '01')
+                    return undefined;
+                text = quote(year);
+                break;
+            case 'gYearMonth':
+                if (!zeroClock || day !== '01')
+                    return undefined;
+                text = quote(year + '-' + month);
+                break;
+            case 'gMonthDay':
+                if (!zeroClock || year !== '2000')
+                    return undefined;
+                text = quote('--' + month + '-' + day);
+                break;
+            case 'gDay':
+                if (!zeroClock || year !== '2000' || month !== '01')
+                    return undefined;
+                text = quote('---' + day);
+                break;
+            case 'gMonth':
+                if (!zeroClock || year !== '2000' || day !== '01')
+                    return undefined;
+                text = quote('--' + month);
+                break;
+        }
+        c.step(owner, text.length + zone.length * 2 + 1);
+        return text + quote(zone);
+    };
+    for (const offset of offsets()) {
+        c.step(owner, 4);
+        const local = shifted(offset * 60), instant = showInstant(local, budget);
+        const zone = calendar.zoned ? (offset < 0 ? '-' : '+') + two(Math.floor(Math.abs(offset) / 60)) + ':' + two(Math.abs(offset) % 60) : '';
+        c.step(owner, 4);
+        const zones = calendar.zoned && offset === 0 ? ['Z', '+00:00', '-00:00'] : [zone];
+        for (const zone of zones) {
+            const normal = expression(instant, zone);
+            if (normal !== undefined)
+                yield normal;
+            if (calendar.family !== 'dateTime' && calendar.family !== 'time')
+                continue;
+            // Second 60 is an overflow into the next minute, including fractions.
+            if (/T[0-9]{2}:[0-9]{2}:00(?:\.[0-9]+)?Z$/.test(instant)) {
+                budget.arithmetic(local.digits + local.scale + 8);
+                c.step(owner, 4);
+                const priorMinute = showInstant({ ...local, coefficient: local.coefficient - 60n * power }, budget);
+                const overflow = expression(priorMinute, zone, true);
+                if (overflow !== undefined)
+                    yield overflow;
+            }
+            if (/T00:00:00Z$/.test(instant)) {
+                budget.arithmetic(local.digits + local.scale + 8);
+                c.step(owner, 4);
+                const priorDay = showInstant({ ...local, coefficient: local.coefficient - 86400n * power }, budget);
+                const midnight = expression(priorDay, zone, false, true);
+                if (midnight !== undefined)
+                    yield midnight;
+            }
+        }
+    }
+}
+/** Finite field decompositions, each with its complete infinite zero aliases. */
+export function* durationAliasExpressions(duration, owner, c, canMatch) {
+    const digits = duration.digits + duration.seconds.scale + 8;
+    const arithmetic = () => c.step(owner, (digits + 2) ** 2);
+    arithmetic();
+    const months = duration.months < 0n ? -duration.months : duration.months;
+    const seconds = duration.seconds.coefficient < 0n ? -duration.seconds.coefficient : duration.seconds.coefficient;
+    const power = 10n ** BigInt(duration.seconds.scale), unit = 60n * power;
+    const sign = duration.months < 0n || duration.seconds.coefficient < 0n ? '\\-' : '';
+    const integer = (number) => { arithmetic(); c.step(owner, digits + 4); return number === 0n ? '0+' : '0*' + number; };
+    const field = (number, suffix) => {
+        const value = integer(number);
+        c.step(owner, value.length + 8);
+        return number === 0n ? '(' + value + suffix + ')?' : value + suffix;
+    };
+    const second = (coefficient) => {
+        arithmetic();
+        c.step(owner, digits * 4 + 8);
+        const whole = coefficient / power, remainder = coefficient % power;
+        const fraction = remainder === 0n ? '([.]0+)?' : '[.]' + remainder.toString().padStart(duration.seconds.scale, '0').replace(/0+$/, '') + '0*';
+        return integer(whole) + fraction + 'S';
+    };
+    const zeroTime = () => {
+        c.step(owner, 4);
+        const choices = [];
+        for (let mask = 1; mask < 8; mask++) {
+            c.step(owner, 64);
+            choices.push('T' + (mask & 1 ? '0+H' : '') + (mask & 2 ? '0+M' : '') + (mask & 4 ? '0+([.]0+)?S' : ''));
+        }
+        c.step(owner, 256);
+        return '(' + choices.join('|') + ')?';
+    };
+    const branch = (y, m, d, h, minute, remainder) => {
+        const prefix = sign + 'P' + field(y, 'Y') + field(m, 'M') + field(d, 'D');
+        c.step(owner, prefix.length + digits * 8 + 64);
+        return h === 0n && minute === 0n && remainder === 0n ? prefix + zeroTime()
+            : prefix + 'T' + field(h, 'H') + field(minute, 'M') + (remainder === 0n ? '(' + second(0n) + ')?' : second(remainder));
+    };
+    if (months === 0n && seconds === 0n) {
+        for (let mask = 1; mask < 64; mask++) {
+            c.step(owner, 96);
+            const date = (mask & 1 ? '0+Y' : '') + (mask & 2 ? '0+M' : '') + (mask & 4 ? '0+D' : '');
+            const time = (mask & 8 ? '0+H' : '') + (mask & 16 ? '0+M' : '') + (mask & 32 ? '0+([.]0+)?S' : '');
+            yield '\\-?P' + date + (time ? 'T' + time : '');
+        }
+        return;
+    }
+    // A conventional decomposition supplies a cheap complete-language branch
+    // before exhaustive finite alternatives; no failure of it proves absence.
+    arithmetic();
+    const y = months / 12n, m = months % 12n, d = seconds / (86400n * power);
+    const rest = seconds - d * 86400n * power, h = rest / (3600n * power), restHour = rest - h * 3600n * power;
+    const minute = restHour / unit;
+    yield branch(y, m, d, h, minute, restHour - minute * unit);
+    for (let year = 0n; year * 12n <= months; year++) {
+        arithmetic();
+        const month = months - year * 12n;
+        const datePrefix = sign + 'P' + field(year, 'Y') + field(month, 'M');
+        c.step(owner, datePrefix.length + 128);
+        if (!canMatch(datePrefix + '([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+([.][0-9]+)?S)?)?'))
+            continue;
+        for (let day = 0n; day * 86400n * power <= seconds; day++) {
+            arithmetic();
+            const remaining = seconds - day * 86400n * power, prefix = datePrefix + field(day, 'D');
+            c.step(owner, prefix.length + 96);
+            if (!canMatch(prefix + '(T([0-9]+H)?([0-9]+M)?([0-9]+([.][0-9]+)?S)?)?'))
+                continue;
+            for (let hour = 0n; hour * 3600n * power <= remaining; hour++) {
+                arithmetic();
+                const afterHour = remaining - hour * 3600n * power;
+                c.step(owner, prefix.length + digits * 4 + 96);
+                if (!canMatch(prefix + 'T' + field(hour, 'H') + '([0-9]+M)?([0-9]+([.][0-9]+)?S)?')) {
+                    if (hour !== 0n || afterHour !== 0n)
+                        continue;
+                }
+                for (let min = 0n; min * unit <= afterHour; min++) {
+                    arithmetic();
+                    const remainingSeconds = afterHour - min * unit;
+                    yield branch(year, month, day, hour, min, remainingSeconds);
+                }
+            }
+        }
+    }
+}

package/dist/compiler/schemaTokenImages.d.ts

@@ -0,0 +1,8 @@
+/** Finite token-boundary transducers with complete source-owned value labels. */
+import type { SchemaPatternContext } from './schemaValueContext.js';
+import type { RegularLanguage } from './schemaRegularLanguage.js';
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+import type { SymbolicSequence } from './schemaSymbolicSequences.js';
+export declare function schemaTokenImages<Owner, Label>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, token: (owner: Owner) => RegularLanguage, labels: (paths: RegularLanguage, position: number, rejected: readonly number[], owner: Owner) => readonly Label[], whitespace: (codepoint: number, owner: Owner) => Label): {
+    image: (source: RegularLanguage, rejectedCount: number, maximumPosition: number, mode: "list" | "string", owner: Owner) => SymbolicSequence<Label>;
+};

package/dist/compiler/schemaTokenImages.js

@@ -0,0 +1,142 @@
+import { schemaRegularLanguages } from './schemaRegularLanguage.js';
+export function schemaTokenImages(c, regular, token, labels, whitespace) {
+    const image = (source, rejectedCount, maximumPosition, mode, owner) => {
+        const program = regular.automaton(source, owner), tokenDomain = token(owner);
+        const maskCost = Math.min(Number.MAX_SAFE_INTEGER, (rejectedCount + 4) ** 2);
+        const masks = (operations = 1) => c.step(owner, Math.min(Number.MAX_SAFE_INTEGER, maskCost * operations));
+        c.step(owner, rejectedCount + 16);
+        masks(2);
+        const all = (1n << BigInt(rejectedCount)) - 1n;
+        const inputs = [], states = [], known = new Map();
+        const intern = (state) => {
+            c.step(owner, 64);
+            masks(2);
+            const key = state.at + ':' + state.failed + ':' + state.position + ':' + state.after, before = known.get(key);
+            if (before !== undefined)
+                return before;
+            c.step(owner, 6);
+            const index = states.length;
+            known.set(key, index);
+            inputs.push(state);
+            states.push({ accepting: program.states[state.at].accepting && state.failed === all, edges: [] });
+            return index;
+        };
+        const start = intern({ at: program.start, failed: 0n, position: 0, after: false });
+        const gaps = [9, 10, 13, 32];
+        c.step(owner, program.states.length * 3 + 6);
+        const pathCache = new Map(), labelCache = new WeakMap();
+        const incoming = program.states.map(() => []), productive = new Set(), pending = [];
+        for (let at = 0; at < program.states.length; at++) {
+            if (program.states[at].accepting) {
+                c.step(owner, 2);
+                productive.add(at);
+                pending.push(at);
+            }
+            for (const edge of program.states[at].transitions) {
+                c.step(owner);
+                incoming[edge.to].push(at);
+            }
+        }
+        while (pending.length)
+            for (const at of incoming[pending.pop()]) {
+                c.step(owner);
+                if (!productive.has(at)) {
+                    c.step(owner, 2);
+                    productive.add(at);
+                    pending.push(at);
+                }
+            }
+        for (let cursor = 0; cursor < inputs.length; cursor++) {
+            const from = inputs[cursor];
+            c.step(owner);
+            if (mode === 'string')
+                for (const edge of program.states[from.at].transitions)
+                    for (const cp of gaps) {
+                        c.step(owner);
+                        if (cp < edge.lo || cp > edge.hi)
+                            continue;
+                        const to = intern({ ...from, at: edge.to, after: false });
+                        c.step(owner, 3);
+                        states[cursor].edges.push({ to, label: whitespace(cp, owner) });
+                    }
+            if (from.after)
+                continue;
+            for (let end = 0; end < program.states.length; end++) {
+                c.step(owner);
+                const endpoint = program.states[end];
+                if (!productive.has(end))
+                    continue;
+                if (!endpoint.accepting && !endpoint.transitions.some(edge => gaps.some(cp => edge.lo <= cp && edge.hi >= cp)))
+                    continue;
+                c.step(owner, 32);
+                const key = from.at + ':' + end;
+                let paths = pathCache.get(key);
+                if (!paths) {
+                    paths = regular.intersect([regular.paths(program, [from.at], new Set([end]), owner), tokenDomain], owner);
+                    c.step(owner, 2);
+                    pathCache.set(key, paths);
+                }
+                if (regular.witness(paths, owner) === undefined)
+                    continue;
+                c.step(owner, rejectedCount * 3 + 6);
+                const missing = [];
+                for (let bit = 0; bit < rejectedCount; bit++) {
+                    masks(2);
+                    if (!(from.failed & (1n << BigInt(bit))))
+                        missing.push(bit);
+                }
+                masks();
+                const limit = 1n << BigInt(missing.length);
+                for (let mask = 0n; mask < limit;) {
+                    c.step(owner, missing.length * 3 + 6);
+                    const rejected = [];
+                    let failed = from.failed;
+                    for (let bit = 0; bit < missing.length; bit++) {
+                        masks(2);
+                        if (mask & (1n << BigInt(bit))) {
+                            rejected.push(missing[bit]);
+                            masks(2);
+                            failed |= 1n << BigInt(missing[bit]);
+                        }
+                    }
+                    masks();
+                    mask++;
+                    c.step(owner, rejected.length * 16 + 6);
+                    const labelKey = from.position + ':' + JSON.stringify(rejected);
+                    let table = labelCache.get(paths);
+                    if (!table) {
+                        c.step(owner, 2);
+                        table = new Map();
+                        labelCache.set(paths, table);
+                    }
+                    let selected = table.get(labelKey);
+                    if (!selected) {
+                        selected = labels(paths, from.position, rejected, owner);
+                        c.step(owner, 2);
+                        table.set(labelKey, selected);
+                    }
+                    if (!selected.length)
+                        continue;
+                    const position = Math.min(maximumPosition, from.position + 1), destinations = [];
+                    if (mode === 'string')
+                        destinations.push(intern({ at: end, failed, position, after: true }));
+                    else {
+                        if (endpoint.accepting)
+                            destinations.push(intern({ at: end, failed, position, after: true }));
+                        for (const edge of endpoint.transitions) {
+                            c.step(owner);
+                            if (edge.lo <= 32 && edge.hi >= 32)
+                                destinations.push(intern({ at: edge.to, failed, position, after: false }));
+                        }
+                    }
+                    c.step(owner, destinations.length * selected.length * 3 + 2);
+                    for (const to of destinations)
+                        for (const label of selected)
+                            states[cursor].edges.push({ to, label });
+                }
+            }
+        }
+        return { start, states };
+    };
+    return { image };
+}

package/dist/compiler/schemaTypeIdentity.d.ts

@@ -0,0 +1,38 @@
+/** Internal semantic type identities. Call within the shared request guard. */
+import type { AttributeNode, ComplexTypeNode, ElementNode, NodeId, SimpleTypeNode } from './canonicalGraph.js';
+import type { ExpandedName } from '../loader/orderedSyntax.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { OriginalGeneratedScalarReference, SemanticTypeIdentity, SemanticTypeReference } from './semanticTypeReference.js';
+export type SemanticTypeResolution = Readonly<{
+    kind: 'component';
+    node: SimpleTypeNode | ComplexTypeNode;
+    identity: Readonly<{
+        kind: 'component';
+        id: NodeId;
+    }>;
+}> | Readonly<{
+    kind: 'builtin';
+    name: ExpandedName;
+    identity: Readonly<{
+        kind: 'builtin';
+        name: ExpandedName;
+    }>;
+}> | Readonly<{
+    kind: 'original-generated';
+    slot: OriginalGeneratedScalarReference;
+    identity: OriginalGeneratedScalarReference;
+}> | Readonly<{
+    kind: 'missing';
+    reference: SemanticTypeReference;
+}> | Readonly<{
+    kind: 'outside-context';
+    reference: SemanticTypeReference;
+}> | Readonly<{
+    kind: 'wrong-role';
+    reference: SemanticTypeReference;
+    component: NodeId;
+}>;
+export declare function resolveSemanticType(context: SemanticContext, reference: SemanticTypeReference): SemanticTypeResolution;
+export declare function declaredType(context: SemanticContext, node: ElementNode | AttributeNode): SemanticTypeReference;
+/** Collision-free key only; supplied identity data is not lookup authority. */
+export declare function semanticTypeKey(context: SemanticContext, identity: SemanticTypeIdentity): string;

package/dist/compiler/schemaTypeIdentity.js

@@ -0,0 +1,80 @@
+import { isBuiltinType } from './canonicalGraph.js';
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { assertSemanticContext, SemanticContextAccessError } from './semanticContext.js';
+export function resolveSemanticType(context, reference) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    const kind = ownField(context, reference, 'kind');
+    budget.chargeWork(8);
+    if (kind === 'original-generated') {
+        const found = context.lookupScalarSlot(reference);
+        return found.kind === 'found' ? Object.freeze({ kind: 'original-generated', slot: found.slot, identity: found.slot })
+            : Object.freeze({ kind: found.kind, reference: budget.freeze(budget.snapshot(reference)) });
+    }
+    let found;
+    try {
+        found = context.resolve(reference);
+    }
+    catch (error) {
+        if (error instanceof SemanticContextAccessError && error.code === 'reference') {
+            budget.chargeWork(4);
+            throw new TypeError('Malformed semantic type reference');
+        }
+        throw error;
+    }
+    if (found.kind === 'builtin') {
+        if (found.name.namespace !== XSD_NAMESPACE || !isBuiltinType(found.name.local))
+            throw new TypeError('Unknown builtin type');
+        return Object.freeze({ kind: 'builtin', name: found.name, identity: Object.freeze({ kind: 'builtin', name: found.name }) });
+    }
+    if (found.kind === 'standard-element')
+        return Object.freeze({ kind: 'wrong-role', reference: budget.freeze(budget.snapshot(reference)), component: found.declaration.id });
+    if (found.kind !== 'found')
+        return Object.freeze({ kind: found.kind, reference: budget.freeze(budget.snapshot(reference)) });
+    if (context.originalSourceComponentAbsent(found.node.id) || found.node.kind !== 'simpleType' && found.node.kind !== 'complexType')
+        return Object.freeze({ kind: 'wrong-role', reference: budget.freeze(budget.snapshot(reference)), component: found.node.id });
+    return Object.freeze({ kind: 'component', node: found.node, identity: Object.freeze({ kind: 'component', id: found.node.id }) });
+}
+export function declaredType(context, node) {
+    assertSemanticContext(context);
+    context.budget.chargeWork(48);
+    const field = node && typeof node === 'object' ? Object.getOwnPropertyDescriptor(node, 'id') : undefined;
+    if (!field || !('value' in field) || typeof field.value !== 'string')
+        throw new TypeError('Unauthenticated declaration');
+    const found = context.lookup(field.value);
+    if (found.kind !== 'found' || found.node !== node || node.kind !== 'element' && node.kind !== 'attribute')
+        throw new TypeError('Unauthenticated declaration');
+    return node.kind === 'element' ? context.rawElementProperties(node.id)?.type ?? node.type
+        : context.rawAttributeProperties(node.id)?.type ?? node.type;
+}
+/** Own primitive data only: a key cannot establish membership or validity. */
+function ownField(context, value, name) {
+    context.budget.chargeWork(56 + name.length);
+    if (!value || typeof value !== 'object')
+        throw new TypeError('Expected own semantic identity data');
+    const field = Object.getOwnPropertyDescriptor(value, name);
+    if (!field || !('value' in field))
+        throw new TypeError('Semantic identity fields must be own data');
+    return field.value;
+}
+function stringField(context, value, name) {
+    const field = ownField(context, value, name);
+    if (typeof field !== 'string')
+        throw new TypeError('Semantic identity field must be a string');
+    return field;
+}
+/** Collision-free key only; supplied identity data is not lookup authority. */
+export function semanticTypeKey(context, identity) {
+    assertSemanticContext(context);
+    const budget = context.budget, kind = stringField(context, identity, 'kind');
+    if (kind === 'component' || kind === 'original-generated') {
+        const id = stringField(context, identity, kind === 'component' ? 'id' : 'owner');
+        budget.chargeWork(id.length * 2 + 20);
+        return (kind === 'component' ? 'component:' : 'generated:') + id.length + ':' + id;
+    }
+    if (kind !== 'builtin')
+        throw new TypeError('Malformed semantic type identity');
+    const name = ownField(context, identity, 'name'), namespace = stringField(context, name, 'namespace'), local = stringField(context, name, 'local');
+    budget.chargeWork((namespace.length + local.length) * 2 + 20);
+    return 'builtin:' + namespace.length + ':' + namespace + ':' + local.length + ':' + local;
+}

package/dist/compiler/schemaTypeRelations.d.ts

@@ -0,0 +1,37 @@
+import type { SemanticTypeReference as Reference, SemanticTypeDependency } from './semanticTypeReference.js';
+/** XSD 1.0 dated local relations. Success never certifies component/schema validity. */
+import type { GraphNode, NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+export type DerivationMethod = 'extension' | 'restriction' | 'list' | 'union';
+export type RelationReceipt<T = boolean> = Readonly<{
+    kind: 'checked';
+    value: T;
+    contextId: string;
+    authority: 'XSD10-local-relations-v1';
+    obligations: readonly ('component-validity' | 'complete-substitution-universe')[];
+    dependencies: readonly string[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+export type RelationFailure = Readonly<{
+    kind: 'unresolved' | 'invalid-input';
+    rule: string;
+    component?: string;
+    message: string;
+}>;
+export type RelationResult<T = boolean> = RelationReceipt<T> | RelationFailure | ResourceLimitFailure;
+export type SubstitutionOptions = Readonly<{
+    mode: 'affiliation' | 'substitutability';
+    blocking?: readonly ('extension' | 'restriction' | 'substitution')[];
+}>;
+export declare class RelationProblem extends Error {
+    readonly result: RelationFailure;
+    constructor(result: RelationFailure);
+}
+/** The graph mapping owns legal syntax; this parser diagnoses token-list errors locally. */
+export declare function declarationMethods(context: SemanticContext, node: GraphNode, property: 'final' | 'block'): readonly (DerivationMethod | 'substitution')[];
+export declare const checkTypeDerivation: (context: SemanticContext, derived: Reference, base: Reference, excluded: readonly DerivationMethod[]) => RelationResult;
+export declare const checkImmediateTypeFinal: (context: SemanticContext, derived: Reference) => RelationResult;
+export declare const immediateTypeBase: (context: SemanticContext, reference: Reference) => RelationResult<Reference | undefined>;
+export declare const checkSubstitution: (context: SemanticContext, member: NodeId, head: NodeId, options: SubstitutionOptions) => RelationResult;
+export declare const effectiveSubstitutionMembers: (context: SemanticContext, head: NodeId) => RelationResult<readonly NodeId[]>;