gdc-sdk-node-ts 0.12.0 → 2.0.2

package/dist/backend-profile-runtime.js

@@ -0,0 +1,436 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ActorKinds } from 'gdc-common-utils-ts/constants/actor-session';
+import { ProfileAppTypes } from 'gdc-common-utils-ts/constants';
+import { JobStatus } from 'gdc-common-utils-ts/models/confidential-job';
+import { buildActorSessionDescriptorForActorKind, expandActorSessionDescriptorToFacades, prepareLoadedActorProfile, prepareLoadProfile, } from 'gdc-sdk-core-ts';
+import { createActorSessionsFromFacades } from './gdc-session-bridge.js';
+export const BackendSubjectIndexReadModes = Object.freeze({
+    LatestIps: 'latest-ips',
+    ClinicalBundle: 'clinical-bundle',
+});
+/**
+ * Default backend-generic runtime implementation backed by injected adapters.
+ *
+ * This class is the first concrete v2 slice intended for backend consumers that
+ * need one reusable actor-aware profile runtime after authentication.
+ */
+export class BackendProfileRuntime {
+    constructor(adapters, options = {}) {
+        this.adapters = adapters;
+        this.options = options;
+    }
+    async loadProfile(input) {
+        const loadedProfile = await this.adapters.loadProfile(input);
+        return {
+            ...loadedProfile,
+            actorSessions: createActorSessionsFromFacades(loadedProfile.facades, this.options.facadeClient),
+        };
+    }
+    async closeProfile(_profileKey) { }
+    async registerTrustedDevice(input) {
+        return this.adapters.registerTrustedDevice(input);
+    }
+    async connectToSubjectIndex(input) {
+        return this.adapters.connectToSubjectIndex(input);
+    }
+    async getSubjectIndexComposition(input) {
+        return this.adapters.getSubjectIndexComposition(input);
+    }
+}
+/**
+ * Current concrete backend profile runtime over one injected runtime client.
+ *
+ * This is the pragmatic v2 bridge for backend consumers that already possess
+ * an authenticated `RuntimeClient` and need `loadProfile(...)` to materialize
+ * actor facades immediately against the current GW CORE contract.
+ */
+export class DirectBackendProfileRuntime {
+    constructor(options) {
+        this.loadedProfiles = new Map();
+        this.options = options;
+    }
+    async loadProfile(input) {
+        const normalized = prepareLoadProfile(input);
+        const profileId = String(normalized.profileId
+            || normalized.profileDid
+            || normalized.subjectDid
+            || normalized.providerDid).trim();
+        const resolvedAppType = normalized.appType || ProfileAppTypes.Family;
+        const descriptor = {
+            profileId,
+            actorKind: normalized.actorKind,
+            actorRole: normalized.actorRole,
+            providerDid: normalized.providerDid,
+            runtimeClass: normalized.runtimeClass,
+            profileDid: normalized.profileDid,
+            subjectDid: normalized.subjectDid,
+            email: normalized.email,
+            phone: normalized.phone,
+            deviceDid: normalized.deviceDid,
+            appType: resolvedAppType,
+        };
+        const session = buildActorSessionDescriptorForActorKind({
+            actorKind: normalized.actorKind,
+            appType: resolvedAppType,
+            profileId: descriptor.profileId,
+            profileDid: descriptor.profileDid,
+            role: descriptor.actorRole,
+        });
+        const facades = expandActorSessionDescriptorToFacades(session);
+        const jobManager = this.options.createJobManager
+            ? this.options.createJobManager(descriptor, normalized)
+            : createJobManagerInMemory(descriptor);
+        const loadedProfile = prepareLoadedActorProfile({
+            descriptor,
+            session,
+            facades,
+            jobManager,
+        });
+        const backendProfile = {
+            ...loadedProfile,
+            actorSessions: createActorSessionsFromFacades(loadedProfile.facades, this.options.facadeClient),
+        };
+        this.rememberLoadedProfile(backendProfile);
+        return backendProfile;
+    }
+    async closeProfile(profileKey) {
+        const profile = this.resolveLoadedProfile(profileKey);
+        profile.jobManager.shutdown();
+        this.forgetLoadedProfile(profile);
+    }
+    async registerTrustedDevice(input) {
+        if (this.options.registerTrustedDevice) {
+            return this.options.registerTrustedDevice(input);
+        }
+        return {
+            trustedDeviceId: input.deviceDid,
+            status: 'already-trusted',
+        };
+    }
+    async connectToSubjectIndex(input) {
+        if (this.options.connectToSubjectIndex) {
+            return this.options.connectToSubjectIndex(input);
+        }
+        return {
+            subjectId: input.subjectId,
+            userId: input.userId,
+            userRoleCode: input.userRoleCode,
+            status: 'already-connected',
+        };
+    }
+    async getSubjectIndexComposition(input) {
+        if (this.options.getSubjectIndexComposition) {
+            return this.options.getSubjectIndexComposition(input);
+        }
+        const routeContext = this.options.defaultRouteContext;
+        if (!routeContext) {
+            throw new Error('DirectBackendProfileRuntime requires defaultRouteContext to read subject index data.');
+        }
+        const profile = this.resolveLoadedProfile(input.userId);
+        if (profile.descriptor.actorKind !== ActorKinds.IndividualController) {
+            throw new Error(`DirectBackendProfileRuntime currently resolves subject index reads through IndividualController only, not '${profile.descriptor.actorKind}'.`);
+        }
+        const sdk = requireBackendIndividualControllerSdk(profile);
+        if (this.options.subjectIndexReadMode === BackendSubjectIndexReadModes.ClinicalBundle) {
+            const searchResult = await sdk.searchClinicalBundle(routeContext, {
+                subject: input.subjectId,
+            });
+            return {
+                subjectId: input.subjectId,
+                userId: input.userId,
+                userRoleCode: input.userRoleCode,
+                composition: searchResult.poll.body,
+            };
+        }
+        const latestIps = await sdk.getLatestIps(routeContext, {
+            subject: input.subjectId,
+        });
+        return {
+            subjectId: input.subjectId,
+            userId: input.userId,
+            userRoleCode: input.userRoleCode,
+            composition: latestIps.poll.body,
+        };
+    }
+    rememberLoadedProfile(profile) {
+        const keys = new Set([
+            profile.descriptor.profileId,
+            String(profile.descriptor.profileDid || '').trim(),
+            String(profile.descriptor.subjectDid || '').trim(),
+            String(profile.descriptor.email || '').trim(),
+            String(profile.descriptor.phone || '').trim(),
+        ].filter(Boolean));
+        for (const key of keys) {
+            this.loadedProfiles.set(key, profile);
+        }
+    }
+    forgetLoadedProfile(profile) {
+        const keys = new Set([
+            profile.descriptor.profileId,
+            String(profile.descriptor.profileDid || '').trim(),
+            String(profile.descriptor.subjectDid || '').trim(),
+            String(profile.descriptor.email || '').trim(),
+            String(profile.descriptor.phone || '').trim(),
+        ].filter(Boolean));
+        for (const key of keys) {
+            this.loadedProfiles.delete(key);
+        }
+    }
+    resolveLoadedProfile(userId) {
+        const normalizedUserId = String(userId || '').trim();
+        const direct = this.loadedProfiles.get(normalizedUserId);
+        if (direct) {
+            return direct;
+        }
+        throw new Error(`DirectBackendProfileRuntime has not loaded one backend profile for '${normalizedUserId}'.`);
+    }
+}
+/**
+ * Minimal in-memory `JobManager` for backend runtimes that do not need durable
+ * persistence during one live session.
+ */
+export function createJobManagerInMemory(descriptor) {
+    let isInitialized = false;
+    let sequence = 0;
+    const jobs = new Map();
+    let listener;
+    function notify() {
+        listener?.();
+    }
+    function nextSequence() {
+        sequence += 1;
+        return sequence;
+    }
+    function inferFormType(content) {
+        const first = Array.isArray(content?.body?.data) ? content.body.data[0] : undefined;
+        return String(first?.type || content?.type || '').trim();
+    }
+    function cloneJob(job) {
+        return {
+            ...job,
+            indexed: job.indexed ? structuredClone(job.indexed) : job.indexed,
+            content: job.content ? structuredClone(job.content) : job.content,
+            jwe: job.jwe ? structuredClone(job.jwe) : job.jwe,
+        };
+    }
+    function matchesQuery(job, query) {
+        const conditions = Array.isArray(query.where) ? query.where : [];
+        return conditions.every((condition) => {
+            const currentValue = job[condition.attribute];
+            if ('equals' in condition) {
+                return currentValue === condition.equals;
+            }
+            if ('in' in condition) {
+                return Array.isArray(condition.in) && condition.in.includes(currentValue);
+            }
+            return true;
+        });
+    }
+    return {
+        descriptor: { ...descriptor },
+        get isInitialized() {
+            return isInitialized;
+        },
+        async initialize() {
+            isInitialized = true;
+        },
+        shutdown() {
+            isInitialized = false;
+            jobs.clear();
+        },
+        setListener(nextListener) {
+            listener = nextListener;
+        },
+        async createJob(content, selector) {
+            const now = Date.now();
+            const job = {
+                id: createRuntimeUuid(),
+                thid: String(content?.thid || '').trim() || undefined,
+                status: JobStatus.DRAFT,
+                sequence: nextSequence(),
+                createdAtTimestamp: now,
+                content: structuredClone(content),
+                ...selector,
+            };
+            jobs.set(job.id, job);
+            notify();
+            return cloneJob(job);
+        },
+        async findDraftJobByFormType(formType) {
+            const normalizedFormType = String(formType || '').trim();
+            for (const job of jobs.values()) {
+                if (job.status !== JobStatus.DRAFT)
+                    continue;
+                if (inferFormType(job.content) === normalizedFormType) {
+                    return cloneJob(job);
+                }
+            }
+            return null;
+        },
+        async createOrUpdateDraftJob(content, selector) {
+            const formType = inferFormType(content);
+            const existing = formType ? await this.findDraftJobByFormType(formType) : null;
+            if (!existing) {
+                return this.createJob(content, selector);
+            }
+            const current = jobs.get(existing.id);
+            if (!current) {
+                return this.createJob(content, selector);
+            }
+            const updated = {
+                ...current,
+                ...selector,
+                thid: String(content?.thid || '').trim() || current.thid,
+                content: structuredClone(content),
+                previousSequence: current.sequence,
+                sequence: nextSequence(),
+            };
+            jobs.set(updated.id, updated);
+            notify();
+            return cloneJob(updated);
+        },
+        async sync() { },
+        async queryJobs(query) {
+            const filtered = [...jobs.values()].filter(job => matchesQuery(job, query));
+            if (query.orderBy) {
+                const { attribute, direction } = query.orderBy;
+                filtered.sort((left, right) => {
+                    const a = left[attribute];
+                    const b = right[attribute];
+                    if (a === b)
+                        return 0;
+                    const cmp = a > b ? 1 : -1;
+                    return direction === 'desc' ? -cmp : cmp;
+                });
+            }
+            const offset = Math.max(0, Number(query.offset || 0));
+            const limit = query.limit == null ? filtered.length : Math.max(0, Number(query.limit));
+            return filtered.slice(offset, offset + limit).map(cloneJob);
+        },
+        async submitJob(job) {
+            const current = jobs.get(job.id);
+            if (!current) {
+                throw new Error(`JobManager in-memory store cannot submit unknown job '${job.id}'.`);
+            }
+            jobs.set(job.id, {
+                ...current,
+                status: JobStatus.SENT,
+                previousSequence: current.sequence,
+                sequence: nextSequence(),
+            });
+            notify();
+        },
+        async sealJobWithToken(job) {
+            return job;
+        },
+        async getJobResponseByThid(thid) {
+            for (const job of jobs.values()) {
+                if (job.thid === thid && job.responseMessageId) {
+                    return {
+                        id: job.responseMessageId,
+                        thid,
+                    };
+                }
+            }
+            return null;
+        },
+        generateId() {
+            return createRuntimeUuid();
+        },
+    };
+}
+/**
+ * Requires one backend profile-runtime method from one runtime client.
+ */
+export function requireBackendProfileRuntimeMethod(client, method) {
+    const candidate = client[method];
+    if (typeof candidate !== 'function') {
+        throw new Error(`BackendProfileRuntimeClient does not implement '${String(method)}'.`);
+    }
+    return candidate.bind(client);
+}
+/**
+ * Canonical backend helper for loading one actor profile after authentication.
+ */
+export async function loadBackendProfile(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'loadProfile')(input);
+}
+/**
+ * Canonical backend helper for closing one loaded actor profile and clearing
+ * runtime-owned in-memory state.
+ */
+export async function closeBackendProfile(client, profileKey) {
+    return requireBackendProfileRuntimeMethod(client, 'closeProfile')(profileKey);
+}
+/**
+ * Canonical backend helper for registering one trusted device/runtime context.
+ */
+export async function registerBackendTrustedDevice(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'registerTrustedDevice')(input);
+}
+/**
+ * Canonical backend helper for connecting one actor profile to one subject
+ * index after the profile is already loaded.
+ */
+export async function connectBackendToSubjectIndex(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'connectToSubjectIndex')(input);
+}
+/**
+ * Canonical backend helper for reading one subject index composition after the
+ * relationship is already established.
+ */
+export async function getBackendSubjectIndexComposition(client, input) {
+    return requireBackendProfileRuntimeMethod(client, 'getSubjectIndexComposition')(input);
+}
+/**
+ * Returns one materialized backend actor session by actor kind.
+ *
+ * Backend callers should use this instead of scanning `actorSessions` manually.
+ */
+export function requireBackendActorSession(profile, actorKind) {
+    const session = profile.actorSessions.find(candidate => candidate.actorKind === actorKind);
+    if (!session) {
+        throw new Error(`Loaded backend profile does not expose actor kind '${actorKind}'.`);
+    }
+    return session;
+}
+/**
+ * Returns the individual-controller session from one loaded backend profile.
+ *
+ * This helper is the first concrete bridge from the generic backend runtime to
+ * the current individual bootstrap/index use case.
+ */
+export function requireBackendIndividualControllerSession(profile) {
+    return requireBackendActorSession(profile, ActorKinds.IndividualController);
+}
+/**
+ * Materializes the individual-controller facade directly from one loaded
+ * backend profile.
+ */
+export function requireBackendIndividualControllerSdk(profile) {
+    return requireBackendIndividualControllerSession(profile).asIndividualController();
+}
+/**
+ * Loads one backend profile and resolves the individual-controller session in
+ * one step.
+ *
+ * This is the first pragmatic use-case helper on top of the generic backend
+ * profile runtime, because the current stable CORE bootstrap baseline starts
+ * from the individual-controller flow.
+ */
+export async function loadBackendIndividualControllerProfile(client, input) {
+    const profile = await loadBackendProfile(client, input);
+    const session = requireBackendIndividualControllerSession(profile);
+    return {
+        profile,
+        session,
+        sdk: session.asIndividualController(),
+    };
+}
+function createRuntimeUuid() {
+    const fromCrypto = globalThis.crypto?.randomUUID?.();
+    if (fromCrypto) {
+        return fromCrypto;
+    }
+    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

package/dist/consent-claim-helpers.d.ts

@@ -1,4 +1,5 @@
 /**
  * Node runtime re-export of canonical consent claim helpers.
  */
-export { addActorIdentifierList, addActorRoleList, addActors, addCategories, addCategoryList, addClaimValues, addPurposeList, addPurposes, addRoles, addSections, getActorIdentifierList, getActorRoleList, getActors, getCategories, getCategoryList, getClaimValues, getConsentDate, getConsentIdentifier, getConsentPeriodEnd, getConsentPeriodStart, getPurposeList, getPurposes, getRoles, getSections, setActorIdentifierList, setActorRoleList, setActors, setCategories, setCategoryList, setClaimValues, setConsentDate, setConsentIdentifier, setConsentPeriodEnd, setConsentPeriodStart, setPurposeList, setPurposes, setRoles, setSections, type ConsentInteroperableClaims, } from 'gdc-sdk-core-ts';
+export { addActorIdentifierList, addActorRoleList, addActors, addCategories, addCategoryList, addClaimValues, addPurposeList, addPurposes, addRoles, addSections, getActorIdentifierList, getActorRoleList, getActors, getCategories, getCategoryList, getClaimValues, getConsentDate, getConsentIdentifier, getConsentPeriodEnd, getConsentPeriodStart, getPurposeList, getPurposes, getRoles, getSections, setActorIdentifierList, setActorRoleList, setActors, setCategories, setCategoryList, setClaimValues, setConsentDate, setConsentIdentifier, setConsentPeriodEnd, setConsentPeriodStart, setPurposeList, setPurposes, setRoles, setSections, } from 'gdc-sdk-core-ts';
+export type { ConsentInteroperableClaims, } from 'gdc-sdk-core-ts';

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export * from 'gdc-sdk-core-ts';
 export * from './runtime-contracts.js';
 export * from './identity-bootstrap.js';
 export * from './async-polling.js';
+export * from './backend-profile-runtime.js';
+export * from './individual-controller-backend-runtime.js';
 export * from './poll-options.js';
 export * from './host-onboarding.js';
 export * from './individual-start.js';

package/dist/index.js

@@ -3,6 +3,8 @@ export * from 'gdc-sdk-core-ts';
 export * from './runtime-contracts.js';
 export * from './identity-bootstrap.js';
 export * from './async-polling.js';
+export * from './backend-profile-runtime.js';
+export * from './individual-controller-backend-runtime.js';
 export * from './poll-options.js';
 export * from './host-onboarding.js';
 export * from './individual-start.js';

package/dist/individual-controller-backend-runtime.d.ts

@@ -0,0 +1,46 @@
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import type { IndividualOrganizationConfirmOrderInput, RouteContext } from './individual-onboarding.js';
+import type { IndividualOrganizationBootstrapInput, IndividualOrganizationStartResult } from './individual-start.js';
+import type { ClinicalBundleSearchInput } from './resource-operations.js';
+import { type BackendIndividualControllerProfile, type BackendProfileRuntimeClient } from './backend-profile-runtime.js';
+import type { ProfileLoadRequest } from 'gdc-sdk-core-ts';
+/**
+ * Backend use-case facade for the current individual-controller baseline.
+ *
+ * This class does not redefine the generic backend profile runtime. It wraps
+ * that runtime with the current stable CORE-facing actions that backend
+ * consumers need first:
+ *
+ * - load an individual-controller profile
+ * - start individual registration/bootstrap
+ * - confirm the returned order/offer
+ * - search the subject clinical index
+ * - request the latest IPS-oriented bundle
+ */
+export declare class IndividualControllerBackendRuntime {
+    private readonly profileRuntime;
+    constructor(profileRuntime: BackendProfileRuntimeClient);
+    /**
+     * Loads one individual-controller backend profile and materializes its actor
+     * facade in one step.
+     */
+    loadProfile(input: ProfileLoadRequest): Promise<BackendIndividualControllerProfile>;
+    /**
+     * Starts the current CORE individual/family bootstrap flow.
+     */
+    startIndividualOrganization(profile: BackendIndividualControllerProfile, input: IndividualOrganizationBootstrapInput): Promise<IndividualOrganizationStartResult>;
+    /**
+     * Confirms the order returned by the individual bootstrap flow.
+     */
+    confirmIndividualOrganizationOrder(profile: BackendIndividualControllerProfile, input: IndividualOrganizationConfirmOrderInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches the current subject clinical bundle index through the loaded
+     * individual-controller facade.
+     */
+    searchClinicalBundle(profile: BackendIndividualControllerProfile, ctx: RouteContext, input: ClinicalBundleSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Reads the latest IPS-oriented bundle through the loaded
+     * individual-controller facade.
+     */
+    getLatestIps(profile: BackendIndividualControllerProfile, ctx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes'>): Promise<SubmitAndPollResult>;
+}

package/dist/individual-controller-backend-runtime.js

@@ -0,0 +1,53 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { loadBackendIndividualControllerProfile, } from './backend-profile-runtime.js';
+/**
+ * Backend use-case facade for the current individual-controller baseline.
+ *
+ * This class does not redefine the generic backend profile runtime. It wraps
+ * that runtime with the current stable CORE-facing actions that backend
+ * consumers need first:
+ *
+ * - load an individual-controller profile
+ * - start individual registration/bootstrap
+ * - confirm the returned order/offer
+ * - search the subject clinical index
+ * - request the latest IPS-oriented bundle
+ */
+export class IndividualControllerBackendRuntime {
+    constructor(profileRuntime) {
+        this.profileRuntime = profileRuntime;
+    }
+    /**
+     * Loads one individual-controller backend profile and materializes its actor
+     * facade in one step.
+     */
+    loadProfile(input) {
+        return loadBackendIndividualControllerProfile(this.profileRuntime, input);
+    }
+    /**
+     * Starts the current CORE individual/family bootstrap flow.
+     */
+    startIndividualOrganization(profile, input) {
+        return profile.sdk.startIndividualOrganization(input);
+    }
+    /**
+     * Confirms the order returned by the individual bootstrap flow.
+     */
+    confirmIndividualOrganizationOrder(profile, input) {
+        return profile.sdk.confirmIndividualOrganizationOrder(input);
+    }
+    /**
+     * Searches the current subject clinical bundle index through the loaded
+     * individual-controller facade.
+     */
+    searchClinicalBundle(profile, ctx, input) {
+        return profile.sdk.searchClinicalBundle(ctx, input);
+    }
+    /**
+     * Reads the latest IPS-oriented bundle through the loaded
+     * individual-controller facade.
+     */
+    getLatestIps(profile, ctx, input) {
+        return profile.sdk.getLatestIps(ctx, input);
+    }
+}

package/dist/node-runtime-client.d.ts

@@ -1,12 +1,13 @@
+import type { OrganizationDidBindingInput } from 'gdc-sdk-core-ts';
 import type { AppInfo } from 'gdc-sdk-core-ts';
 import { type ResolvedAppInfo } from 'gdc-sdk-core-ts';
 import { type HostRouteContext, type HostedTenantLifecycleInput } from './host-onboarding.js';
-import type { NodeOrganizationActivationInput } from './orchestration/client-port.js';
+import type { NodeLegalOrganizationVerificationTransactionInput, NodeOrganizationDidBindingInput, NodeOrganizationActivationInput } from './orchestration/client-port.js';
 import { type IndividualOrganizationConfirmOrderInput, type RouteContext } from './individual-onboarding.js';
 import { type SmartTokenRequestInput } from './smart-token.js';
 import { type OrganizationLicenseOrderConfirmInput } from './organization-license-order.js';
 import { type IndividualOrganizationBootstrapInput, type IndividualOrganizationStartResult } from './individual-start.js';
-import { type CommunicationIngestionInput, type ClinicalBundleSearchInput, type GrantProfessionalAccessInput, type GrantProfessionalAccessResult, type IndividualMemberLifecycleInput, type IndividualOrganizationLifecycleInput, type LicenseListRuntimeSearchInput, type LicenseOfferRuntimeSearchInput, type LicenseOrderRuntimeSearchInput, type OrganizationEmployeeCreationInput, type OrganizationEmployeeLifecycleInput, type OrganizationEmployeeSearchInput, type RelatedPersonUpsertInput } from './resource-operations.js';
+import { type CommunicationIngestionInput, type CommunicationParticipantRuntimeSearchInput, type ClinicalBundleSearchInput, type GrantProfessionalAccessInput, type GrantProfessionalAccessResult, type IndividualMemberLifecycleInput, type IndividualOrganizationLifecycleInput, type LicenseListRuntimeSearchInput, type LicenseOfferRuntimeSearchInput, type LicenseOrderRuntimeSearchInput, type OrganizationEmployeeCreationInput, type OrganizationEmployeeLifecycleInput, type OrganizationEmployeeSearchInput, type RelatedPersonUpsertInput } from './resource-operations.js';
 import type { LegalOrganizationOrderInput } from './host-onboarding.js';
 import type { SmartTokenExchangeResult } from './smart-token.js';
 import type { NodeRuntimeClient, PollOptions, PollResult, SubmitAndPollResult, SubmitPayload, SubmitResponse } from './orchestration/client-port.js';
@@ -109,9 +110,45 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
      * Convenience wrapper that performs submit and poll in sequence.
      */
     submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    /**
+     * Starts the host-side legal-organization verification transaction that GW
+     * CORE forwards to ICA `_verify`.
+     *
+     * Runtime ownership:
+     * - builds the canonical shared business bundle from `sdk-core/common-utils`
+     * - keeps communication/runtime transport concerns at the outer message layer
+     * - keeps the controller business key inside the submitted bundle payload
+     *
+     * Flow separation:
+     * - `_transaction` is the first host onboarding step
+     * - `_activate` remains a later step that consumes the ICA proof
+     */
+    submitLegalOrganizationVerificationTransaction(hostCtx: HostRouteContext, input: NodeLegalOrganizationVerificationTransactionInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    /**
+     * Submits one tenant-scoped DID document binding request.
+     *
+     * Binding semantics:
+     * - the tenant path identifies the existing organization
+     * - `organization.url` carries the public alias/domain list
+     * - `controller.sameAs` is optional corroborating identity material
+     * - the flow does not rotate or replace organization public keys
+     */
+    submitOrganizationDidBinding(ctx: RouteContext, input: NodeOrganizationDidBindingInput | OrganizationDidBindingInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /**
      * Activates a legal organization in the gateway host registry using an ICA
      * proof token already obtained by the caller.
+     *
+     * Plaintext transport note:
+     * - this Node runtime currently submits `_activate` as
+     *   `application/didcomm-plaintext+json`
+     * - because there is no real outer JWS/JWE envelope in that mode, the
+     *   runtime mirrors the technical communication metadata derived from
+     *   `controller.publicKeyJwk` / `controller.jwks` into `meta.jws.protected`
+     *   and `meta.jwe.header`
+     * - secure JOSE transports should carry those values in the real protected
+     *   headers instead of plaintext `meta`
+     * - this mirrored metadata is transport fallback only; the canonical
+     *   activation contract remains `body.vp_token` plus `body.controller.*`
      */
     activateOrganizationInGatewayFromIcaProof(hostCtx: HostRouteContext, input: NodeOrganizationActivationInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /**
@@ -274,6 +311,11 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
      * @param input Communication payload plus route/format options.
      */
     ingestCommunicationAndUpdateIndex(ctx: RouteContext, input: CommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches communication channel records by subject and participant
+     * identifiers through `Communication/_search`.
+     */
+    searchCommunicationParticipants(ctx: RouteContext, input: CommunicationParticipantRuntimeSearchInput): Promise<SubmitAndPollResult>;
     /**
      * Alias for `ingestCommunicationAndUpdateIndex(...)`.
      *
@@ -319,8 +361,15 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
     private parseResponseBody;
     private requireRouteContext;
     private routeCtxFromInput;
+    /**
+     * Reuses the shared bundle business contract while keeping attachment
+     * transport fields at the DIDComm/plaintext message layer expected by GW.
+     */
+    private wrapBundleAsGatewayTransactionMessage;
     private hostRegistryPath;
     private requireHostRouteContext;
+    hostRegistryOrganizationTransactionPath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationTransactionPollPath(ctx?: HostRouteContext): string;
     hostRegistryOrganizationActivatePath(ctx?: HostRouteContext): string;
     hostRegistryOrganizationActivatePollPath(ctx?: HostRouteContext): string;
     hostRegistryOrganizationDisablePath(ctx?: HostRouteContext): string;
@@ -335,6 +384,8 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
     employeeSearchPollPath(ctx?: RouteContext): string;
     organizationLicenseSearchPath(ctx?: RouteContext): string;
     organizationLicenseSearchPollPath(ctx?: RouteContext): string;
+    organizationDidBindingPath(ctx?: RouteContext): string;
+    organizationDidBindingPollPath(ctx?: RouteContext): string;
     organizationLicenseOfferSearchPath(ctx?: RouteContext): string;
     organizationLicenseOfferSearchPollPath(ctx?: RouteContext): string;
     organizationLicenseOrderSearchPath(ctx?: RouteContext): string;
@@ -365,6 +416,8 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
     individualConsentR4PollPath(ctx: RouteContext): string;
     individualCommunicationBatchPath(ctx: RouteContext, format: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4'): string;
     individualCommunicationPollPath(ctx: RouteContext, format: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4'): string;
+    individualCommunicationSearchPath(ctx: RouteContext): string;
+    individualCommunicationSearchPollPath(ctx: RouteContext): string;
     individualBundleSearchPath(ctx: RouteContext): string;
     individualBundleSearchPollPath(ctx: RouteContext): string;
     identityTokenExchangePath(ctx: RouteContext): string;