gdc-sdk-node-ts 0.9.1 → 2.0.2

package/dist/node-runtime-client.js

@@ -2,14 +2,17 @@
 // Always create JSDoc, do not use strings inline in keys nor values, use types instead, and reuse the data test examples.
 import fs from 'node:fs';
 import path from 'node:path';
-import { buildAppHeaders, createBootstrapFacade, resolveAppInfo, } from 'gdc-sdk-core-ts';
+import { buildLegalOrganizationVerificationGatewayRequestBundle, buildOrganizationDidBindingBundle, buildAppHeaders, createBootstrapFacade, resolveAppInfo, } from 'gdc-sdk-core-ts';
 import { buildConsentClaimsSimpleWithCid } from 'gdc-common-utils-ts/utils/consent';
+import { buildDidcommPlaintextTransportMetadata } from 'gdc-common-utils-ts/utils/activation-request';
 import { pollUntilCompleteWithMethod } from './async-polling.js';
-import { confirmLegalOrganizationOrderWithDeps } from './host-onboarding.js';
+import { confirmLegalOrganizationOrderWithDeps, HostLifecycleRequestType, HostedTenantLifecycleRequestType, submitHostedTenantLifecycleWithDeps, } from './host-onboarding.js';
 import { confirmIndividualOrganizationOrderWithDeps, } from './individual-onboarding.js';
 import { requestSmartTokenWithDeps } from './smart-token.js';
+import { extractOfferIdFromResponseBody, extractOfferPreviewFromResponseBody, } from './order-offer-summary.js';
+import { confirmOrganizationLicenseOrderWithDeps } from './organization-license-order.js';
 import { startIndividualOrganizationWithDeps } from './individual-start.js';
-import { createOrganizationEmployeeWithDeps, disableIndividualOrganizationWithDeps, disableOrganizationEmployeeWithDeps, grantProfessionalAccessWithDeps, ingestCommunicationAndUpdateIndexWithDeps, purgeIndividualOrganizationWithDeps, purgeOrganizationEmployeeWithDeps, searchOrganizationEmployeesWithDeps, searchClinicalBundleWithDeps, searchLatestIpsWithDeps, upsertRelatedPersonAndPollWithDeps, } from './resource-operations.js';
+import { createOrganizationEmployeeWithDeps, disableIndividualMemberWithDeps, disableIndividualOrganizationWithDeps, disableOrganizationEmployeeWithDeps, listIndividualLicenseOffersWithDeps, listIndividualLicenseOrdersWithDeps, listIndividualLicensesWithDeps, listOrganizationLicenseOffersWithDeps, listOrganizationLicenseOrdersWithDeps, listOrganizationLicensesWithDeps, grantProfessionalAccessWithDeps, ingestCommunicationAndUpdateIndexWithDeps, searchCommunicationParticipantsWithDeps, purgeIndividualMemberWithDeps, purgeIndividualOrganizationWithDeps, purgeOrganizationEmployeeWithDeps, searchIndividualLicensesWithDeps, searchIndividualLicenseOffersWithDeps, searchIndividualLicenseOrdersWithDeps, searchOrganizationLicensesWithDeps, searchOrganizationLicenseOffersWithDeps, searchOrganizationLicenseOrdersWithDeps, searchOrganizationEmployeesWithDeps, searchClinicalBundleWithDeps, searchLatestIpsWithDeps, upsertRelatedPersonAndPollWithDeps, } from './resource-operations.js';
 import { submitAndPollWithMethods } from './orchestration/client-port.js';
 import { GwCoreLifecycleAction } from './constants/lifecycle.js';
 const bootstrapFacade = createBootstrapFacade();
@@ -94,9 +97,66 @@ export class HttpRuntimeClient {
     async submitAndPoll(submitPath, pollPath, payload, pollOptions) {
         return submitAndPollWithMethods(this, submitPath, pollPath, payload, pollOptions);
     }
+    /**
+     * 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
+     */
+    async submitLegalOrganizationVerificationTransaction(hostCtx, input, pollOptions) {
+        const thid = `organization-verification-transaction-${runtimeUuid()}`;
+        const jti = `organization-verification-transaction-jti-${runtimeUuid()}`;
+        const verificationBundle = buildLegalOrganizationVerificationGatewayRequestBundle(input);
+        const payload = this.wrapBundleAsGatewayTransactionMessage({
+            thid,
+            jti,
+            hostCtx,
+            bundle: verificationBundle,
+        });
+        return this.submitAndPoll(this.hostRegistryOrganizationTransactionPath(hostCtx), this.hostRegistryOrganizationTransactionPollPath(hostCtx), payload, pollOptions);
+    }
+    /**
+     * 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
+     */
+    async submitOrganizationDidBinding(ctx, input, pollOptions) {
+        const thid = `organization-did-binding-${runtimeUuid()}`;
+        const jti = `organization-did-binding-jti-${runtimeUuid()}`;
+        const payload = {
+            jti,
+            thid,
+            type: 'application/api+json',
+            body: buildOrganizationDidBindingBundle(input),
+        };
+        return this.submitAndPoll(this.organizationDidBindingPath(ctx), this.organizationDidBindingPollPath(ctx), payload, pollOptions);
+    }
     /**
      * 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.*`
      */
     async activateOrganizationInGatewayFromIcaProof(hostCtx, input, pollOptions) {
         const thid = `activate-org-${runtimeUuid()}`;
@@ -107,11 +167,16 @@ export class HttpRuntimeClient {
             additionalClaims: input.additionalClaims,
         });
         const serviceClaims = activationDraft.buildServiceClaims();
+        const transportMeta = buildDidcommPlaintextTransportMetadata({
+            controller: input.controller,
+            contentType: 'application/didcomm-plaintext+json',
+        });
         const payload = {
             thid,
             iss: String(hostCtx.controllerDid || '').trim() || undefined,
             aud: String(hostCtx.hostDid || '').trim() || undefined,
             type: 'application/api+json',
+            ...(transportMeta ? { meta: transportMeta } : {}),
             body: {
                 vp_token: input.vpToken,
                 ...(input.controller ? { controller: input.controller } : {}),
@@ -152,6 +217,73 @@ export class HttpRuntimeClient {
             defaultIntervalMs: pollOptions?.intervalMs,
         });
     }
+    /**
+     * Disables the host registration itself after every hosted tenant has
+     * already been purged from the host registry.
+     */
+    async disableHost(hostCtx, input, pollOptions) {
+        return submitHostedTenantLifecycleWithDeps({
+            hostCtx,
+            input,
+            requestType: HostLifecycleRequestType.Disable,
+            submitPath: this.hostRegistryOrganizationDisablePath.bind(this),
+            pollPath: this.hostRegistryOrganizationDisablePollPath.bind(this),
+            thidPrefix: 'host-disable',
+            submitAndPoll: this.submitAndPoll.bind(this),
+            defaultTimeoutMs: pollOptions?.timeoutMs,
+            defaultIntervalMs: pollOptions?.intervalMs,
+        });
+    }
+    /**
+     * Purges the disabled host registration after the hosted tenant registry has
+     * become empty.
+     */
+    async purgeHost(hostCtx, input, pollOptions) {
+        return submitHostedTenantLifecycleWithDeps({
+            hostCtx,
+            input,
+            requestType: HostLifecycleRequestType.Purge,
+            submitPath: this.hostRegistryOrganizationPurgePath.bind(this),
+            pollPath: this.hostRegistryOrganizationPurgePollPath.bind(this),
+            thidPrefix: 'host-purge',
+            submitAndPoll: this.submitAndPoll.bind(this),
+            defaultTimeoutMs: pollOptions?.timeoutMs,
+            defaultIntervalMs: pollOptions?.intervalMs,
+        });
+    }
+    /**
+     * Disables one hosted tenant through the host registry after its descendants
+     * have already been disabled/purged.
+     */
+    async disableTenant(hostCtx, input, pollOptions) {
+        return submitHostedTenantLifecycleWithDeps({
+            hostCtx,
+            input,
+            requestType: HostedTenantLifecycleRequestType.Disable,
+            submitPath: this.hostRegistryOrganizationDisablePath.bind(this),
+            pollPath: this.hostRegistryOrganizationDisablePollPath.bind(this),
+            thidPrefix: 'tenant-disable',
+            submitAndPoll: this.submitAndPoll.bind(this),
+            defaultTimeoutMs: pollOptions?.timeoutMs,
+            defaultIntervalMs: pollOptions?.intervalMs,
+        });
+    }
+    /**
+     * Purges one already-disabled hosted tenant through the host registry.
+     */
+    async purgeTenant(hostCtx, input, pollOptions) {
+        return submitHostedTenantLifecycleWithDeps({
+            hostCtx,
+            input,
+            requestType: HostedTenantLifecycleRequestType.Purge,
+            submitPath: this.hostRegistryOrganizationPurgePath.bind(this),
+            pollPath: this.hostRegistryOrganizationPurgePollPath.bind(this),
+            thidPrefix: 'tenant-purge',
+            submitAndPoll: this.submitAndPoll.bind(this),
+            defaultTimeoutMs: pollOptions?.timeoutMs,
+            defaultIntervalMs: pollOptions?.intervalMs,
+        });
+    }
     /**
      * Creates an employee or professional entry under an existing organization tenant.
      */
@@ -210,6 +342,77 @@ export class HttpRuntimeClient {
             submitAndPoll: this.submitAndPoll.bind(this),
         });
     }
+    /**
+     * Searches organization-owned license seats through the canonical
+     * `License/_search` route.
+     */
+    async searchOrganizationLicenses(ctx, input) {
+        return searchOrganizationLicensesWithDeps(ctx, input, {
+            organizationLicenseSearchPath: this.organizationLicenseSearchPath.bind(this),
+            organizationLicenseSearchPollPath: this.organizationLicenseSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    /**
+     * Lists organization-owned license seats using the same `License/_search`
+     * route with optional filters.
+     */
+    async listOrganizationLicenses(ctx, input = {}) {
+        return listOrganizationLicensesWithDeps(ctx, input, {
+            organizationLicenseSearchPath: this.organizationLicenseSearchPath.bind(this),
+            organizationLicenseSearchPollPath: this.organizationLicenseSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async searchOrganizationLicenseOffers(ctx, input) {
+        return searchOrganizationLicenseOffersWithDeps(ctx, input, {
+            organizationLicenseOfferSearchPath: this.organizationLicenseOfferSearchPath.bind(this),
+            organizationLicenseOfferSearchPollPath: this.organizationLicenseOfferSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async listOrganizationLicenseOffers(ctx, input = {}) {
+        return listOrganizationLicenseOffersWithDeps(ctx, input, {
+            organizationLicenseOfferSearchPath: this.organizationLicenseOfferSearchPath.bind(this),
+            organizationLicenseOfferSearchPollPath: this.organizationLicenseOfferSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async searchOrganizationLicenseOrders(ctx, input) {
+        return searchOrganizationLicenseOrdersWithDeps(ctx, input, {
+            organizationLicenseOrderSearchPath: this.organizationLicenseOrderSearchPath.bind(this),
+            organizationLicenseOrderSearchPollPath: this.organizationLicenseOrderSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async listOrganizationLicenseOrders(ctx, input = {}) {
+        return listOrganizationLicenseOrdersWithDeps(ctx, input, {
+            organizationLicenseOrderSearchPath: this.organizationLicenseOrderSearchPath.bind(this),
+            organizationLicenseOrderSearchPollPath: this.organizationLicenseOrderSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    /**
+     * Confirms an already paid organization-side license order so additional
+     * seats become usable once GW CORE exposes the public converged route.
+     *
+     * Current runtime note:
+     * - search/list for organization license offers and orders already works
+     * - the public/write post-payment seat activation route is not wired yet
+     * - this method therefore fails explicitly instead of guessing a transport
+     *   contract that is not stable in GW CORE
+     */
+    async confirmOrganizationLicenseOrder(ctx, input, pollOptions) {
+        return confirmOrganizationLicenseOrderWithDeps({
+            routeCtx: ctx,
+            input,
+            defaultTimeoutMs: pollOptions?.timeoutMs,
+            defaultIntervalMs: pollOptions?.intervalMs,
+            hostRegistryOrderBatchPath: this.hostRegistryOrderBatchPath.bind(this),
+            hostRegistryOrderPollPath: this.hostRegistryOrderPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
     /**
      * Starts the onboarding flow for an individual-oriented tenant or index.
      */
@@ -221,8 +424,8 @@ export class HttpRuntimeClient {
             individualFamilyOrganizationBatchPath: this.individualFamilyOrganizationTransactionPath.bind(this),
             individualFamilyOrganizationPollPath: this.individualFamilyOrganizationTransactionPollPath.bind(this),
             submitAndPoll: this.submitAndPoll.bind(this),
-            getOfferIdFromResponse: (result) => this.extractOfferId(result.poll.body),
-            getOfferPreviewFromResponse: () => ({}),
+            getOfferIdFromResponse: (result) => extractOfferIdFromResponseBody(result.poll.body),
+            getOfferPreviewFromResponse: (result) => extractOfferPreviewFromResponseBody(result.poll.body),
         });
     }
     /**
@@ -277,13 +480,65 @@ export class HttpRuntimeClient {
         return this.purgeIndividualOrganization(ctx, input, pollOptions);
     }
     /**
-     * Placeholder for a future GW CORE member/caregiver lifecycle contract.
-     *
-     * Current GW CORE does not yet expose a stable lifecycle route for
-     * `RelatedPerson` / individual-member disable.
+     * Soft-disables a `RelatedPerson` membership/contact using the current
+     * public batch-update path and `RelatedPerson.active = false`.
+     */
+    async disableIndividualMember(ctx, input, pollOptions) {
+        return disableIndividualMemberWithDeps(ctx, input, pollOptions, {
+            individualRelatedPersonBatchPath: this.individualRelatedPersonBatchPath.bind(this),
+            individualRelatedPersonPollPath: this.individualRelatedPersonPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    /**
+     * Searches individual/family-side license seats through the canonical
+     * `License/_search` route.
+     */
+    async searchIndividualLicenses(ctx, input) {
+        return searchIndividualLicensesWithDeps(ctx, input, {
+            individualLicenseSearchPath: this.individualLicenseSearchPath.bind(this),
+            individualLicenseSearchPollPath: this.individualLicenseSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    /**
+     * Lists individual/family-side license seats using the same search route
+     * with optional filters.
      */
-    async disableIndividualMember(_ctx, _input, _pollOptions) {
-        throw new Error('disableIndividualMember is not supported by the current GW CORE contract. TODO(gw-core-lifecycle-target-member-disable).');
+    async listIndividualLicenses(ctx, input = {}) {
+        return listIndividualLicensesWithDeps(ctx, input, {
+            individualLicenseSearchPath: this.individualLicenseSearchPath.bind(this),
+            individualLicenseSearchPollPath: this.individualLicenseSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async searchIndividualLicenseOffers(ctx, input) {
+        return searchIndividualLicenseOffersWithDeps(ctx, input, {
+            individualLicenseOfferSearchPath: this.individualLicenseOfferSearchPath.bind(this),
+            individualLicenseOfferSearchPollPath: this.individualLicenseOfferSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async listIndividualLicenseOffers(ctx, input = {}) {
+        return listIndividualLicenseOffersWithDeps(ctx, input, {
+            individualLicenseOfferSearchPath: this.individualLicenseOfferSearchPath.bind(this),
+            individualLicenseOfferSearchPollPath: this.individualLicenseOfferSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async searchIndividualLicenseOrders(ctx, input) {
+        return searchIndividualLicenseOrdersWithDeps(ctx, input, {
+            individualLicenseOrderSearchPath: this.individualLicenseOrderSearchPath.bind(this),
+            individualLicenseOrderSearchPollPath: this.individualLicenseOrderSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
+    async listIndividualLicenseOrders(ctx, input = {}) {
+        return listIndividualLicenseOrdersWithDeps(ctx, input, {
+            individualLicenseOrderSearchPath: this.individualLicenseOrderSearchPath.bind(this),
+            individualLicenseOrderSearchPollPath: this.individualLicenseOrderSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
     }
     /**
      * Placeholder for a future GW CORE member/caregiver lifecycle contract.
@@ -291,8 +546,12 @@ export class HttpRuntimeClient {
      * Current GW CORE does not yet expose a stable lifecycle route for
      * `RelatedPerson` / individual-member purge.
      */
-    async purgeIndividualMember(_ctx, _input, _pollOptions) {
-        throw new Error('purgeIndividualMember is not supported by the current GW CORE contract. TODO(gw-core-lifecycle-target-member-purge).');
+    async purgeIndividualMember(ctx, input, pollOptions) {
+        return purgeIndividualMemberWithDeps(ctx, input, pollOptions, {
+            individualRelatedPersonPurgePath: this.individualRelatedPersonPurgePath.bind(this),
+            individualRelatedPersonPurgePollPath: this.individualRelatedPersonPurgePollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
     }
     /**
      * Creates and submits a consent-oriented access grant for a professional actor.
@@ -354,6 +613,17 @@ export class HttpRuntimeClient {
             submitAndPoll: this.submitAndPoll.bind(this),
         });
     }
+    /**
+     * Searches communication channel records by subject and participant
+     * identifiers through `Communication/_search`.
+     */
+    async searchCommunicationParticipants(ctx, input) {
+        return searchCommunicationParticipantsWithDeps(ctx, input, {
+            communicationSearchPath: this.individualCommunicationSearchPath.bind(this),
+            communicationSearchPollPath: this.individualCommunicationSearchPollPath.bind(this),
+            submitAndPoll: this.submitAndPoll.bind(this),
+        });
+    }
     /**
      * Alias for `ingestCommunicationAndUpdateIndex(...)`.
      *
@@ -390,6 +660,12 @@ export class HttpRuntimeClient {
             searchClinicalBundle: this.searchClinicalBundle.bind(this),
         });
     }
+    /**
+     * Preferred runtime alias for latest-IPS retrieval used by shared facades.
+     */
+    async getLatestIps(ctx, input) {
+        return this.searchLatestIps(ctx, input);
+    }
     /**
      * Searches a communication/document thread using `thid` and returns the
      * indexed communication/document projections.
@@ -521,6 +797,24 @@ export class HttpRuntimeClient {
             ? { tenantId, jurisdiction: input.jurisdiction, sector: input.sector }
             : undefined);
     }
+    /**
+     * Reuses the shared bundle business contract while keeping attachment
+     * transport fields at the DIDComm/plaintext message layer expected by GW.
+     */
+    wrapBundleAsGatewayTransactionMessage(input) {
+        const rawBundle = (input.bundle || {});
+        const attachments = Array.isArray(rawBundle.attachments) ? rawBundle.attachments : undefined;
+        const { attachments: _ignoredAttachments, ...body } = rawBundle;
+        return {
+            jti: input.jti,
+            thid: input.thid,
+            iss: String(input.hostCtx.controllerDid || '').trim() || undefined,
+            aud: String(input.hostCtx.hostDid || '').trim() || undefined,
+            type: 'application/api+json',
+            body,
+            ...(attachments && attachments.length > 0 ? { attachments } : {}),
+        };
+    }
     hostRegistryPath(ctx, resourceType, action) {
         const hostCtx = this.requireHostRouteContext(ctx);
         return `/host/cds-${encodeURIComponent(hostCtx.jurisdiction)}/v1/${encodeURIComponent(hostCtx.hostNetwork || '')}/registry/org.schema/${encodeURIComponent(resourceType)}/${encodeURIComponent(action)}`;
@@ -533,14 +827,34 @@ export class HttpRuntimeClient {
             throw new Error('Host route context is required.');
         return { jurisdiction, hostNetwork };
     }
+    hostRegistryOrganizationTransactionPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.Transaction); }
+    hostRegistryOrganizationTransactionPollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.TransactionResponse); }
     hostRegistryOrganizationActivatePath(ctx) { return this.hostRegistryPath(ctx, 'Organization', '_activate'); }
     hostRegistryOrganizationActivatePollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', '_activate-response'); }
+    hostRegistryOrganizationDisablePath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.Disable); }
+    hostRegistryOrganizationDisablePollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', `${GwCoreLifecycleAction.Disable}-response`); }
+    hostRegistryOrganizationPurgePath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.Purge); }
+    hostRegistryOrganizationPurgePollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', `${GwCoreLifecycleAction.Purge}-response`); }
     hostRegistryOrderBatchPath(ctx) { return this.hostRegistryPath(ctx, 'Order', '_batch'); }
     hostRegistryOrderPollPath(ctx) { return this.hostRegistryPath(ctx, 'Order', '_batch-response'); }
     employeeBatchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', GwCoreLifecycleAction.Batch); }
     employeePollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', GwCoreLifecycleAction.BatchResponse); }
     employeeSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', '_search'); }
     employeeSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', '_search-response'); }
+    organizationLicenseSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'License', '_search'); }
+    organizationLicenseSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'License', '_search-response'); }
+    organizationDidBindingPath(ctx) {
+        const resolved = this.requireRouteContext(ctx);
+        return `/${encodeURIComponent(resolved.tenantId)}/cds-${encodeURIComponent(resolved.jurisdiction)}/v1/${encodeURIComponent(resolved.sector)}/did/document/_binding`;
+    }
+    organizationDidBindingPollPath(ctx) {
+        const resolved = this.requireRouteContext(ctx);
+        return `/${encodeURIComponent(resolved.tenantId)}/cds-${encodeURIComponent(resolved.jurisdiction)}/v1/${encodeURIComponent(resolved.sector)}/did/document/_binding-response`;
+    }
+    organizationLicenseOfferSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Offer', '_search'); }
+    organizationLicenseOfferSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Offer', '_search-response'); }
+    organizationLicenseOrderSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Order', '_search'); }
+    organizationLicenseOrderSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Order', '_search-response'); }
     employeePurgePath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', GwCoreLifecycleAction.Purge); }
     employeePurgePollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', `${GwCoreLifecycleAction.Purge}-response`); }
     individualFamilyOrganizationBatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.Batch); }
@@ -551,14 +865,24 @@ export class HttpRuntimeClient {
     individualFamilyOrganizationDisablePollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', `${GwCoreLifecycleAction.Disable}-response`); }
     individualFamilyOrganizationPurgePath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.Purge); }
     individualFamilyOrganizationPurgePollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', `${GwCoreLifecycleAction.Purge}-response`); }
+    individualLicenseSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'License', '_search'); }
+    individualLicenseSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'License', '_search-response'); }
+    individualLicenseOfferSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Offer', '_search'); }
+    individualLicenseOfferSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Offer', '_search-response'); }
+    individualLicenseOrderSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_search'); }
+    individualLicenseOrderSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_search-response'); }
     individualFamilyOrderBatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_batch'); }
     individualFamilyOrderPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_batch-response'); }
     individualRelatedPersonBatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_batch'); }
     individualRelatedPersonPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_batch-response'); }
+    individualRelatedPersonPurgePath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_purge'); }
+    individualRelatedPersonPurgePollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_purge-response'); }
     individualConsentR4BatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Consent', '_batch'); }
     individualConsentR4PollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Consent', '_batch-response'); }
     individualCommunicationBatchPath(ctx, format) { return this.v1Path(ctx, 'individual', format, 'Communication', '_batch'); }
     individualCommunicationPollPath(ctx, format) { return this.v1Path(ctx, 'individual', format, 'Communication', '_batch-response'); }
+    individualCommunicationSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Communication', '_search'); }
+    individualCommunicationSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Communication', '_search-response'); }
     individualBundleSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Bundle', '_search'); }
     individualBundleSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Bundle', '_search-response'); }
     identityTokenExchangePath(ctx) {
@@ -573,19 +897,6 @@ export class HttpRuntimeClient {
     identityOpenIdSmartTokenPollPath(ctx) {
         return `/${encodeURIComponent(ctx.tenantId)}/cds-${encodeURIComponent(ctx.jurisdiction)}/v1/${encodeURIComponent(ctx.sector)}/identity/openid/smart/_batch-response`;
     }
-    extractOfferId(body) {
-        const root = body || {};
-        const bodyNode = root.body || root;
-        const data = bodyNode.data || [];
-        const first = data[0] || {};
-        const firstMeta = first.meta || {};
-        const resource = first.resource || {};
-        const resourceMeta = resource.meta || {};
-        const claims = firstMeta.claims
-            || resourceMeta.claims
-            || {};
-        return String(claims['org.schema.Offer.identifier'] || '').trim() || undefined;
-    }
     appendHttpTrace(entry) {
         if (!this.httpTraceFile)
             return;

package/dist/orchestration/client-port.d.ts

@@ -1,12 +1,16 @@
 import type { ControllerBindingInput } from 'gdc-common-utils-ts/models';
+import type { LegalOrganizationVerificationTransactionInput } from 'gdc-common-utils-ts/utils/legal-organization-verification-transaction';
+import type { OrganizationDidBindingInput } from 'gdc-sdk-core-ts';
+import type { LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput } from '../resource-operations.js';
 import type { AsyncPollRequest, OrganizationActivationServiceOptions, PollOptions, PollResult, SubmitAndPollResult, SubmitPayload, SubmitResponse } from 'gdc-sdk-core-ts';
 export type { AsyncPollRequest, PollOptions, PollResult, SubmitAndPollResult, SubmitPayload, SubmitResponse, } from 'gdc-sdk-core-ts';
 import type { EmployeeDeviceActivationResult, EmployeeDeviceActivationRequestInput } from '../device-activation.js';
-import type { HostRouteContext, LegalOrganizationOrderInput } from '../host-onboarding.js';
+import type { HostRouteContext, HostedTenantLifecycleInput, LegalOrganizationOrderInput } from '../host-onboarding.js';
 import type { IndividualOrganizationConfirmOrderInput, RouteContext } from '../individual-onboarding.js';
 import type { IndividualOrganizationBootstrapInput, IndividualOrganizationStartResult } from '../individual-start.js';
+import type { OrganizationLicenseOrderConfirmInput } from '../organization-license-order.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
-import type { CommunicationIngestionInput, ClinicalBundleSearchInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IndividualOrganizationLifecycleInput, IpsOrFhirImportInput, OrganizationEmployeeCreationInput, OrganizationEmployeeLifecycleInput, OrganizationEmployeeSearchInput, RelatedPersonUpsertInput } from '../resource-operations.js';
+import type { CommunicationIngestionInput, CommunicationParticipantRuntimeSearchInput, ClinicalBundleSearchInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IndividualOrganizationLifecycleInput, IpsOrFhirImportInput, OrganizationEmployeeCreationInput, OrganizationEmployeeLifecycleInput, OrganizationEmployeeSearchInput, RelatedPersonUpsertInput } from '../resource-operations.js';
 /**
  * Shared node-runtime activation input.
  *
@@ -19,6 +23,25 @@ export type NodeOrganizationActivationInput = {
     service?: OrganizationActivationServiceOptions;
     additionalClaims?: Record<string, unknown>;
 };
+/**
+ * Shared node-runtime input for the first host-side legal-organization
+ * verification step.
+ *
+ * The business payload is owned by shared SDK/common packages:
+ * - transport/runtime communication keys stay outside this contract
+ * - controller business key binding remains in `controller.*`
+ * - GW CORE host routing/polling stays in the runtime adapter
+ */
+export type NodeLegalOrganizationVerificationTransactionInput = LegalOrganizationVerificationTransactionInput;
+/**
+ * Shared node-runtime input for the organization DID binding operation.
+ *
+ * Binding contract:
+ * - tenant identity is resolved from the route path
+ * - `organization.url` carries one or more public aliases/domains
+ * - `controller.sameAs` is optional corroborating identity evidence
+ */
+export type NodeOrganizationDidBindingInput = OrganizationDidBindingInput;
 /**
  * Runtime-neutral actor/application client contract as exposed by the Node SDK.
  *
@@ -27,10 +50,23 @@ export type NodeOrganizationActivationInput = {
  * converge across runtimes.
  */
 export type RuntimeClient = {
+    submitLegalOrganizationVerificationTransaction?: (hostCtx: HostRouteContext, input: NodeLegalOrganizationVerificationTransactionInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    submitOrganizationDidBinding?: (ctx: RouteContext, input: NodeOrganizationDidBindingInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     activateOrganizationInGatewayFromIcaProof?: (hostCtx: HostRouteContext, input: NodeOrganizationActivationInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     confirmLegalOrganizationOrder?: (hostCtx: HostRouteContext, input: LegalOrganizationOrderInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    disableHost?: (hostCtx: HostRouteContext, input: HostedTenantLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    purgeHost?: (hostCtx: HostRouteContext, input: HostedTenantLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    disableTenant?: (hostCtx: HostRouteContext, input: HostedTenantLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    purgeTenant?: (hostCtx: HostRouteContext, input: HostedTenantLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     createOrganizationEmployee?: (ctx: RouteContext, input: OrganizationEmployeeCreationInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     searchOrganizationEmployees?: (ctx: RouteContext, input: OrganizationEmployeeSearchInput) => Promise<SubmitAndPollResult>;
+    searchOrganizationLicenses?: (ctx: RouteContext, input: LicenseListRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    listOrganizationLicenses?: (ctx: RouteContext, input?: LicenseListRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    searchOrganizationLicenseOffers?: (ctx: RouteContext, input: LicenseOfferRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    listOrganizationLicenseOffers?: (ctx: RouteContext, input?: LicenseOfferRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    searchOrganizationLicenseOrders?: (ctx: RouteContext, input: LicenseOrderRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    listOrganizationLicenseOrders?: (ctx: RouteContext, input?: LicenseOrderRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    confirmOrganizationLicenseOrder?: (ctx: RouteContext, input: OrganizationLicenseOrderConfirmInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     disableEmployee?: (ctx: RouteContext, input: OrganizationEmployeeLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     purgeEmployee?: (ctx: RouteContext, input: OrganizationEmployeeLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     disableOrganizationEmployee?: (ctx: RouteContext, input: OrganizationEmployeeLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
@@ -46,12 +82,20 @@ export type RuntimeClient = {
     disableIndividualOrganization?: (ctx: RouteContext, input: IndividualOrganizationLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     purgeIndividualOrganization?: (ctx: RouteContext, input: IndividualOrganizationLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     ingestCommunicationAndUpdateIndex?: (ctx: RouteContext, input: CommunicationIngestionInput) => Promise<SubmitAndPollResult>;
+    searchCommunicationParticipants?: (ctx: RouteContext, input: CommunicationParticipantRuntimeSearchInput) => Promise<SubmitAndPollResult>;
     grantProfessionalAccess?: (ctx: RouteContext, input: GrantProfessionalAccessInput) => Promise<GrantProfessionalAccessResult>;
+    searchIndividualLicenses?: (ctx: RouteContext, input: LicenseListRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    listIndividualLicenses?: (ctx: RouteContext, input?: LicenseListRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    searchIndividualLicenseOffers?: (ctx: RouteContext, input: LicenseOfferRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    listIndividualLicenseOffers?: (ctx: RouteContext, input?: LicenseOfferRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    searchIndividualLicenseOrders?: (ctx: RouteContext, input: LicenseOrderRuntimeSearchInput) => Promise<SubmitAndPollResult>;
+    listIndividualLicenseOrders?: (ctx: RouteContext, input?: LicenseOrderRuntimeSearchInput) => Promise<SubmitAndPollResult>;
     bootstrapIndividualOrganization?: (input: IndividualOrganizationBootstrapInput) => Promise<IndividualOrganizationStartResult>;
     importIpsOrFhirAndUpdateIndex?: (ctx: RouteContext, input: IpsOrFhirImportInput) => Promise<SubmitAndPollResult>;
     upsertRelatedPersonAndPoll?: (ctx: RouteContext, input: RelatedPersonUpsertInput) => Promise<SubmitAndPollResult>;
     generateDigitalTwinFromSubjectData?: (ctx: RouteContext, input: DigitalTwinGenerationInput) => Promise<SubmitAndPollResult>;
     searchClinicalBundle?: (ctx: RouteContext, input: ClinicalBundleSearchInput) => Promise<SubmitAndPollResult>;
+    getLatestIps?: (ctx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes'>) => Promise<SubmitAndPollResult>;
     submitBatch?: (submitPath: string, payload: SubmitPayload) => Promise<SubmitResponse>;
     pollUntilComplete?: (pollPath: string, request: AsyncPollRequest, pollOptions?: PollOptions) => Promise<PollResult>;
     submitAndPoll?: (submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;

package/dist/orchestration/host-onboarding-sdk.d.ts

@@ -1,13 +1,25 @@
-import { type NodeOrganizationActivationInput, type NodeRuntimeClient, type PollOptions, type SubmitAndPollResult, type SubmitPayload } from './client-port.js';
-import type { HostRouteContext, LegalOrganizationOrderInput } from '../host-onboarding.js';
-export declare class HostOnboardingSdk {
+import { type NodeRuntimeClient, type NodeOrganizationActivationInput, type PollOptions, type SubmitAndPollResult, type SubmitPayload } from './client-port.js';
+import type { HostingControllerFacade, HostLifecycleInput, HostRouteContext, LegalOrganizationOrderInput } from '../host-onboarding.js';
+import type { NodeCapability } from '../session.js';
+export declare class HostOnboardingSdk implements HostingControllerFacade {
     private readonly client;
-    constructor(client: NodeRuntimeClient);
+    private readonly capabilities;
+    constructor(client: NodeRuntimeClient, capabilities?: readonly NodeCapability[]);
     /**
      * Submits the legal organization activation proof and required declared
      * service capabilities to GW CORE.
      */
     activateOrganizationInGatewayFromIcaProof(hostCtx: HostRouteContext, input: NodeOrganizationActivationInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     confirmLegalOrganizationOrder(hostCtx: HostRouteContext, input: LegalOrganizationOrderInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    /**
+     * Disables the host registration after all hosted tenants have already been
+     * purged and the hosting operator should stop publishing discovery services.
+     */
+    disableHost(hostCtx: HostRouteContext, input: HostLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    /**
+     * Purges the already-disabled host registration once no hosted tenants
+     * remain in the registry.
+     */
+    purgeHost(hostCtx: HostRouteContext, input: HostLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
 }