gdc-sdk-node-ts 0.12.0 → 2.0.4

package/dist/index.d.ts

@@ -2,15 +2,22 @@ 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 './organization-controller-backend-runtime.js';
+export * from './professional-backend-runtime.js';
 export * from './poll-options.js';
 export * from './host-onboarding.js';
 export * from './individual-start.js';
+export * from './family-organization-search.js';
+export * from './family-organization-registration.js';
 export * from './individual-onboarding.js';
 export * from './device-activation.js';
 export * from './smart-token.js';
 export * from './order-offer-summary.js';
 export * from './organization-license-order.js';
 export * from './resource-operations.js';
+export * from './profile-workspace.js';
 export * from './constants/lifecycle.js';
 export * from './consent-claim-helpers.js';
 export * from './session.js';

package/dist/index.js

@@ -3,15 +3,22 @@ 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 './organization-controller-backend-runtime.js';
+export * from './professional-backend-runtime.js';
 export * from './poll-options.js';
 export * from './host-onboarding.js';
 export * from './individual-start.js';
+export * from './family-organization-search.js';
+export * from './family-organization-registration.js';
 export * from './individual-onboarding.js';
 export * from './device-activation.js';
 export * from './smart-token.js';
 export * from './order-offer-summary.js';
 export * from './organization-license-order.js';
 export * from './resource-operations.js';
+export * from './profile-workspace.js';
 export * from './constants/lifecycle.js';
 export * from './consent-claim-helpers.js';
 export * from './session.js';

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

@@ -0,0 +1,59 @@
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import type { FamilyOrganizationSummary } from 'gdc-common-utils-ts/utils/family-organization-summary';
+import type { IndividualOrganizationConfirmOrderInput, RouteContext } from './individual-onboarding.js';
+import type { IndividualOrganizationBootstrapInput, IndividualOrganizationStartResult } from './individual-start.js';
+import type { EnsureFamilyOrganizationRegistrationInput, EnsureFamilyOrganizationRegistrationResult } from './family-organization-registration.js';
+import type { FamilyOrganizationSearchInput } from './family-organization-search.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>;
+    /**
+     * Searches one existing family/individual registration before deciding
+     * whether the backend should create or resume it.
+     */
+    searchFamilyOrganization(profile: BackendIndividualControllerProfile, ctx: RouteContext, input: FamilyOrganizationSearchInput): Promise<FamilyOrganizationSummary | null>;
+    /**
+     * High-level onboarding gate for channel apps:
+     * search the registration first and only bootstrap when still missing.
+     */
+    ensureFamilyOrganizationRegistration(profile: BackendIndividualControllerProfile, ctx: RouteContext, input: EnsureFamilyOrganizationRegistrationInput): Promise<EnsureFamilyOrganizationRegistrationResult>;
+    /**
+     * 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,67 @@
+// 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);
+    }
+    /**
+     * Searches one existing family/individual registration before deciding
+     * whether the backend should create or resume it.
+     */
+    searchFamilyOrganization(profile, ctx, input) {
+        return profile.sdk.searchFamilyOrganization(ctx, input);
+    }
+    /**
+     * High-level onboarding gate for channel apps:
+     * search the registration first and only bootstrap when still missing.
+     */
+    ensureFamilyOrganizationRegistration(profile, ctx, input) {
+        return profile.sdk.ensureFamilyOrganizationRegistration(ctx, 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/legal-organization-onboarding-facade.d.ts

@@ -0,0 +1,70 @@
+import type { LegalOrganizationVerificationRouting, LegalOrganizationVerificationTransactionController, LegalOrganizationVerificationTransactionInput, LegalOrganizationVerificationTransactionOrganization, LegalOrganizationVerificationRepresentativePayload } from 'gdc-common-utils-ts/utils/legal-organization-verification-transaction';
+import type { NodeOrganizationActivationInput } from './orchestration/client-port.js';
+export type LegalOrganizationFormFields = Readonly<{
+    legalName?: string;
+    legalIdentifierType?: string;
+    legalIdentifierValue?: string;
+    taxId?: string;
+    addressCountry?: string;
+    controllerEmail?: string;
+    controllerRole?: string;
+    serviceCategory?: string;
+    serviceIdentifier?: string;
+    serviceUrl?: string;
+}>;
+export type LegalOrganizationOnboardingValidationIssue = Readonly<{
+    severity: 'error' | 'warning';
+    code: string;
+    message: string;
+    field?: keyof LegalOrganizationFormFields | 'claims' | string;
+}>;
+export type LegalOrganizationOnboardingValidationResult = Readonly<{
+    ok: boolean;
+    errors: LegalOrganizationOnboardingValidationIssue[];
+    warnings: LegalOrganizationOnboardingValidationIssue[];
+    normalizedClaims: Record<string, unknown>;
+}>;
+export interface LegalOrganizationOnboardingEditor {
+    setLegalName(value: string): LegalOrganizationOnboardingEditor;
+    setLegalIdentifierType(value: string): LegalOrganizationOnboardingEditor;
+    setLegalIdentifierValue(value: string): LegalOrganizationOnboardingEditor;
+    setTaxId(value: string): LegalOrganizationOnboardingEditor;
+    setAddressCountry(value: string): LegalOrganizationOnboardingEditor;
+    setControllerEmail(value: string): LegalOrganizationOnboardingEditor;
+    setControllerRole(value: string): LegalOrganizationOnboardingEditor;
+    setServiceCategory(value: string): LegalOrganizationOnboardingEditor;
+    setServiceIdentifier(value: string): LegalOrganizationOnboardingEditor;
+    setServiceUrl(value: string): LegalOrganizationOnboardingEditor;
+    getFormFields(): LegalOrganizationFormFields;
+    buildClaims(): Record<string, unknown>;
+    validate(): LegalOrganizationOnboardingValidationResult;
+    buildVerificationTransactionInput(input: Readonly<{
+        controller: LegalOrganizationVerificationTransactionController;
+        organization?: LegalOrganizationVerificationTransactionOrganization;
+        legalRepresentativePayload?: LegalOrganizationVerificationRepresentativePayload;
+        verification?: LegalOrganizationVerificationRouting;
+        attachments?: unknown[];
+    }>): LegalOrganizationVerificationTransactionInput;
+    buildActivationInput(input: Readonly<{
+        vpToken: string;
+        controller: LegalOrganizationVerificationTransactionController;
+        capabilities?: readonly string[];
+    }>): NodeOrganizationActivationInput;
+}
+export interface LegalOrganizationOnboardingFacade {
+    createDraft(initial?: LegalOrganizationFormFields): LegalOrganizationFormFields;
+    createEditor(initial?: LegalOrganizationFormFields): LegalOrganizationOnboardingEditor;
+    setLegalName(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setLegalIdentifierType(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setLegalIdentifierValue(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setTaxId(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setAddressCountry(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setControllerEmail(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setControllerRole(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setServiceCategory(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setServiceIdentifier(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    setServiceUrl(fields: LegalOrganizationFormFields, value: string): LegalOrganizationFormFields;
+    buildClaims(fields: LegalOrganizationFormFields): Record<string, unknown>;
+    validate(fields: LegalOrganizationFormFields): LegalOrganizationOnboardingValidationResult;
+}
+export declare function createLegalOrganizationOnboardingFacade(): LegalOrganizationOnboardingFacade;

package/dist/legal-organization-onboarding-facade.js

@@ -0,0 +1,169 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ClaimsOrganizationSchemaorg, ClaimsPersonSchemaorg, ClaimsServiceSchemaorg, } from 'gdc-common-utils-ts/constants/schemaorg';
+import { ServiceCapability } from 'gdc-common-utils-ts/constants/service-capabilities';
+import { validateLegalOrganizationOnboardingClaims, } from 'gdc-common-utils-ts/utils/legal-organization-onboarding';
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeOptionalText(value) {
+    const normalized = normalizeText(value);
+    return normalized || undefined;
+}
+function cloneFields(fields) {
+    return { ...(fields || {}) };
+}
+function patchFields(fields, patch) {
+    return {
+        ...cloneFields(fields),
+        ...patch,
+    };
+}
+function createIssues(fields) {
+    const issues = [];
+    if (!normalizeOptionalText(fields.legalName)) {
+        issues.push({ severity: 'error', code: 'missing-legal-name', message: 'Legal organization name is required.', field: 'legalName' });
+    }
+    if (!normalizeOptionalText(fields.legalIdentifierType)) {
+        issues.push({ severity: 'error', code: 'missing-legal-identifier-type', message: 'Legal identifier type is required.', field: 'legalIdentifierType' });
+    }
+    if (!normalizeOptionalText(fields.addressCountry)) {
+        issues.push({ severity: 'error', code: 'missing-address-country', message: 'Address country is required.', field: 'addressCountry' });
+    }
+    if (!normalizeOptionalText(fields.controllerEmail)) {
+        issues.push({ severity: 'error', code: 'missing-controller-email', message: 'Controller email is required.', field: 'controllerEmail' });
+    }
+    if (!normalizeOptionalText(fields.serviceCategory)) {
+        issues.push({ severity: 'error', code: 'missing-service-category', message: 'Service category is required.', field: 'serviceCategory' });
+    }
+    return issues;
+}
+function createEditorFromFacade(facade, initial) {
+    let formFields = facade.createDraft(initial);
+    const editor = {
+        setLegalName(value) { formFields = facade.setLegalName(formFields, value); return editor; },
+        setLegalIdentifierType(value) { formFields = facade.setLegalIdentifierType(formFields, value); return editor; },
+        setLegalIdentifierValue(value) { formFields = facade.setLegalIdentifierValue(formFields, value); return editor; },
+        setTaxId(value) { formFields = facade.setTaxId(formFields, value); return editor; },
+        setAddressCountry(value) { formFields = facade.setAddressCountry(formFields, value); return editor; },
+        setControllerEmail(value) { formFields = facade.setControllerEmail(formFields, value); return editor; },
+        setControllerRole(value) { formFields = facade.setControllerRole(formFields, value); return editor; },
+        setServiceCategory(value) { formFields = facade.setServiceCategory(formFields, value); return editor; },
+        setServiceIdentifier(value) { formFields = facade.setServiceIdentifier(formFields, value); return editor; },
+        setServiceUrl(value) { formFields = facade.setServiceUrl(formFields, value); return editor; },
+        getFormFields() { return cloneFields(formFields); },
+        buildClaims() { return facade.buildClaims(formFields); },
+        validate() { return facade.validate(formFields); },
+        buildVerificationTransactionInput(input) {
+            return {
+                claims: facade.buildClaims(formFields),
+                controller: input.controller,
+                ...(input.organization ? { organization: input.organization } : {}),
+                ...(input.legalRepresentativePayload ? { legalRepresentativePayload: input.legalRepresentativePayload } : {}),
+                ...(input.verification ? { verification: input.verification } : {}),
+                ...(input.attachments ? { attachments: input.attachments } : {}),
+            };
+        },
+        buildActivationInput(input) {
+            const claims = facade.buildClaims(formFields);
+            const service = {
+                url: String(claims[ClaimsServiceSchemaorg.url] || '').trim() || undefined,
+                capabilities: [...new Set((input.capabilities || [ServiceCapability.IndexProvider, ServiceCapability.DigitalTwinReader])
+                        .map((item) => String(item || '').trim())
+                        .filter(Boolean))],
+            };
+            return {
+                vpToken: input.vpToken,
+                controller: input.controller,
+                service,
+                additionalClaims: claims,
+            };
+        },
+    };
+    return editor;
+}
+export function createLegalOrganizationOnboardingFacade() {
+    return {
+        createDraft(initial = {}) {
+            return cloneFields(initial);
+        },
+        createEditor(initial = {}) {
+            return createEditorFromFacade(this, initial);
+        },
+        setLegalName(fields, value) {
+            return patchFields(fields, { legalName: normalizeOptionalText(value) });
+        },
+        setLegalIdentifierType(fields, value) {
+            return patchFields(fields, { legalIdentifierType: normalizeOptionalText(value) });
+        },
+        setLegalIdentifierValue(fields, value) {
+            return patchFields(fields, { legalIdentifierValue: normalizeOptionalText(value) });
+        },
+        setTaxId(fields, value) {
+            return patchFields(fields, { taxId: normalizeOptionalText(value) });
+        },
+        setAddressCountry(fields, value) {
+            return patchFields(fields, { addressCountry: normalizeOptionalText(value) });
+        },
+        setControllerEmail(fields, value) {
+            const normalized = normalizeOptionalText(value);
+            return patchFields(fields, { controllerEmail: normalized?.toLowerCase() });
+        },
+        setControllerRole(fields, value) {
+            return patchFields(fields, { controllerRole: normalizeOptionalText(value) });
+        },
+        setServiceCategory(fields, value) {
+            return patchFields(fields, { serviceCategory: normalizeOptionalText(value) });
+        },
+        setServiceIdentifier(fields, value) {
+            return patchFields(fields, { serviceIdentifier: normalizeOptionalText(value) });
+        },
+        setServiceUrl(fields, value) {
+            return patchFields(fields, { serviceUrl: normalizeOptionalText(value) });
+        },
+        buildClaims(fields) {
+            const claims = {
+                '@context': 'org.schema',
+            };
+            if (normalizeOptionalText(fields.legalName))
+                claims[ClaimsOrganizationSchemaorg.legalName] = normalizeText(fields.legalName);
+            if (normalizeOptionalText(fields.legalIdentifierType))
+                claims[ClaimsOrganizationSchemaorg.identifierType] = normalizeText(fields.legalIdentifierType);
+            if (normalizeOptionalText(fields.legalIdentifierValue))
+                claims[ClaimsOrganizationSchemaorg.identifierValue] = normalizeText(fields.legalIdentifierValue);
+            if (normalizeOptionalText(fields.taxId))
+                claims[ClaimsOrganizationSchemaorg.taxId] = normalizeText(fields.taxId);
+            if (normalizeOptionalText(fields.addressCountry))
+                claims[ClaimsOrganizationSchemaorg.addressCountry] = normalizeText(fields.addressCountry);
+            if (normalizeOptionalText(fields.controllerEmail))
+                claims[ClaimsPersonSchemaorg.email] = normalizeText(fields.controllerEmail).toLowerCase();
+            if (normalizeOptionalText(fields.controllerRole))
+                claims[ClaimsPersonSchemaorg.hasOccupationalRoleValue] = normalizeText(fields.controllerRole);
+            if (normalizeOptionalText(fields.serviceCategory))
+                claims[ClaimsServiceSchemaorg.category] = normalizeText(fields.serviceCategory);
+            if (normalizeOptionalText(fields.serviceIdentifier))
+                claims[ClaimsServiceSchemaorg.identifier] = normalizeText(fields.serviceIdentifier);
+            if (normalizeOptionalText(fields.serviceUrl))
+                claims[ClaimsServiceSchemaorg.url] = normalizeText(fields.serviceUrl);
+            return validateLegalOrganizationOnboardingClaims(claims).normalizedClaims;
+        },
+        validate(fields) {
+            const normalizedClaims = this.buildClaims(fields);
+            const issues = createIssues(fields);
+            const sharedValidation = validateLegalOrganizationOnboardingClaims(normalizedClaims);
+            for (const error of sharedValidation.errors) {
+                issues.push({
+                    severity: 'error',
+                    code: error.code.toLowerCase(),
+                    message: error.message,
+                    field: error.claimPaths[0] || 'claims',
+                });
+            }
+            return {
+                ok: !issues.some((issue) => issue.severity === 'error'),
+                errors: issues.filter((issue) => issue.severity === 'error'),
+                warnings: issues.filter((issue) => issue.severity === 'warning'),
+                normalizedClaims,
+            };
+        },
+    };
+}

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

@@ -1,12 +1,15 @@
+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 EnsureFamilyOrganizationRegistrationInput } from './family-organization-registration.js';
+import { type FamilyOrganizationSearchInput } from './family-organization-search.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 RevokeProfessionalAccessInput, type RevokeProfessionalAccessResult, 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 +112,46 @@ 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 new host onboarding step
+     * - this runtime does not chain `_activate` after `_transaction`
+     * - `_activate` remains available only for the older ICA `_verify` based flow
+     */
+    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-plain+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>;
     /**
@@ -196,6 +236,27 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
      * Starts the onboarding flow for an individual-oriented tenant or index.
      */
     startIndividualOrganization(input: IndividualOrganizationBootstrapInput): Promise<IndividualOrganizationStartResult>;
+    /**
+     * Searches one existing family/individual registration by controller phone +
+     * usualname, with optional birth-date disambiguation.
+     */
+    searchFamilyOrganization(ctx: RouteContext, input: FamilyOrganizationSearchInput): Promise<Readonly<{
+        status: import("gdc-common-utils-ts").FamilyRegistrationStatus;
+        offerId?: string;
+        organizationId?: string;
+        subjectInfo?: import("gdc-common-utils-ts").FamilyOrganizationSubjectInfo;
+        missingFields?: string[];
+        updatedAt?: string;
+    }> | null>;
+    /**
+     * Searches one existing family/individual registration and starts the
+     * bootstrap flow only when the registration does not already exist.
+     */
+    ensureFamilyOrganizationRegistration(ctx: RouteContext, input: EnsureFamilyOrganizationRegistrationInput): Promise<Readonly<{
+        status: "already_exists" | "resume_required" | "new_created";
+        summary?: import("gdc-common-utils-ts").FamilyOrganizationSummary;
+        started?: IndividualOrganizationStartResult;
+    }>>;
     /**
      * Confirms the order returned by `startIndividualOrganization(...)`.
      */
@@ -252,6 +313,11 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
      * Creates and submits a consent-oriented access grant for a professional actor.
      */
     grantProfessionalAccess(ctx: RouteContext, input: GrantProfessionalAccessInput): Promise<GrantProfessionalAccessResult>;
+    /**
+     * Closes an existing professional consent by setting its period end and
+     * resubmitting the updated consent resource.
+     */
+    revokeProfessionalAccess(ctx: RouteContext, input: RevokeProfessionalAccessInput): Promise<RevokeProfessionalAccessResult>;
     /**
      * Requests SMART/OpenID token material through the gateway.
      *
@@ -274,6 +340,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 +390,27 @@ 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;
+    /**
+     * Resolves the host route segment without forcing callers to remember whether
+     * the same raw string is named `hostNetwork` or `sector` in a given layer.
+     *
+     * Step by step:
+     * - host routes use `/host/cds-{jurisdiction}/v1/{host-network}`
+     * - tenant routes use `/{tenantId}/cds-{jurisdiction}/v1/{tenant-sector}`
+     * - older live tests and adapters sometimes passed the host segment under
+     *   `sector`, which is semantically wrong for host routes
+     * - new code should prefer `hostNetwork`
+     * - compatibility code may pass `hostNetworkOrTenantSector`
+     */
     private requireHostRouteContext;
+    hostRegistryOrganizationTransactionPath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationTransactionPollPath(ctx?: HostRouteContext): string;
     hostRegistryOrganizationActivatePath(ctx?: HostRouteContext): string;
     hostRegistryOrganizationActivatePollPath(ctx?: HostRouteContext): string;
     hostRegistryOrganizationDisablePath(ctx?: HostRouteContext): string;
@@ -335,6 +425,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;
@@ -343,6 +435,8 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
     employeePurgePollPath(ctx?: RouteContext): string;
     individualFamilyOrganizationBatchPath(ctx?: RouteContext): string;
     individualFamilyOrganizationPollPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationSearchPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationSearchPollPath(ctx?: RouteContext): string;
     individualFamilyOrganizationTransactionPath(ctx?: RouteContext): string;
     individualFamilyOrganizationTransactionPollPath(ctx?: RouteContext): string;
     individualFamilyOrganizationDisablePath(ctx?: RouteContext): string;
@@ -365,6 +459,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;