gdc-sdk-node-ts 0.9.1 → 0.12.0

package/dist/node-runtime-client.js

@@ -5,11 +5,13 @@ import path from 'node:path';
 import { buildAppHeaders, createBootstrapFacade, resolveAppInfo, } from 'gdc-sdk-core-ts';
 import { buildConsentClaimsSimpleWithCid } from 'gdc-common-utils-ts/utils/consent';
 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, 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();
@@ -152,6 +154,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 +279,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 +361,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 +417,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) {
-        throw new Error('disableIndividualMember is not supported by the current GW CORE contract. TODO(gw-core-lifecycle-target-member-disable).');
+    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 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 +483,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.
@@ -390,6 +586,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.
@@ -535,12 +737,22 @@ export class HttpRuntimeClient {
     }
     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'); }
+    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,10 +763,18 @@ 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'); }
@@ -573,19 +793,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,10 +1,12 @@
 import type { ControllerBindingInput } from 'gdc-common-utils-ts/models';
+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';
 /**
@@ -29,8 +31,19 @@ export type NodeOrganizationActivationInput = {
 export type RuntimeClient = {
     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>;
@@ -47,11 +60,18 @@ export type RuntimeClient = {
     purgeIndividualOrganization?: (ctx: RouteContext, input: IndividualOrganizationLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
     ingestCommunicationAndUpdateIndex?: (ctx: RouteContext, input: CommunicationIngestionInput) => 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>;
 }

package/dist/orchestration/host-onboarding-sdk.js

@@ -1,20 +1,41 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 // Always create JSDoc, do not use strings inline in keys nor values, use types instead, and reuse the data test examples.
 import { requireClientMethod, submitAndPollWithClient, } from './client-port.js';
+import { ActorCapabilities, ActorKinds } from 'gdc-common-utils-ts/constants/actor-session';
+import { assertFacadeCapability } from './capability-guard.js';
 export class HostOnboardingSdk {
-    constructor(client) {
+    constructor(client, capabilities = []) {
         this.client = client;
+        this.capabilities = capabilities;
     }
     /**
      * Submits the legal organization activation proof and required declared
      * service capabilities to GW CORE.
      */
     activateOrganizationInGatewayFromIcaProof(hostCtx, input, pollOptions) {
+        assertFacadeCapability(this.capabilities, ActorCapabilities.HostingActivateOrganization, ActorKinds.HostOnboarding, 'activateOrganizationInGatewayFromIcaProof');
         return requireClientMethod(this.client, 'activateOrganizationInGatewayFromIcaProof')(hostCtx, input, pollOptions);
     }
     confirmLegalOrganizationOrder(hostCtx, input, pollOptions) {
+        assertFacadeCapability(this.capabilities, ActorCapabilities.HostingConfirmOrder, ActorKinds.HostOnboarding, 'confirmLegalOrganizationOrder');
         return requireClientMethod(this.client, 'confirmLegalOrganizationOrder')(hostCtx, input, pollOptions);
     }
+    /**
+     * Disables the host registration after all hosted tenants have already been
+     * purged and the hosting operator should stop publishing discovery services.
+     */
+    disableHost(hostCtx, input, pollOptions) {
+        assertFacadeCapability(this.capabilities, ActorCapabilities.HostingDisableHost, ActorKinds.HostOnboarding, 'disableHost');
+        return requireClientMethod(this.client, 'disableHost')(hostCtx, input, pollOptions);
+    }
+    /**
+     * Purges the already-disabled host registration once no hosted tenants
+     * remain in the registry.
+     */
+    purgeHost(hostCtx, input, pollOptions) {
+        assertFacadeCapability(this.capabilities, ActorCapabilities.HostingPurgeHost, ActorKinds.HostOnboarding, 'purgeHost');
+        return requireClientMethod(this.client, 'purgeHost')(hostCtx, input, pollOptions);
+    }
     submitAndPoll(submitPath, pollPath, payload, pollOptions) {
         return submitAndPollWithClient(this.client, submitPath, pollPath, payload, pollOptions);
     }

package/dist/orchestration/individual-controller-sdk.d.ts

@@ -2,7 +2,7 @@ import { type NodeRuntimeClient, type PollOptions, type SubmitAndPollResult, typ
 import type { IndividualOrganizationConfirmOrderInput, RouteContext } from '../individual-onboarding.js';
 import type { IndividualOrganizationBootstrapInput, IndividualOrganizationStartResult } from '../individual-start.js';
 import type { NodeCapability } from '../session.js';
-import type { CommunicationIngestionInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IndividualOrganizationLifecycleInput, IpsOrFhirImportInput, RelatedPersonUpsertInput } from '../resource-operations.js';
+import type { ClinicalBundleSearchInput, CommunicationIngestionInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IndividualOrganizationLifecycleInput, IpsOrFhirImportInput, LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput, RelatedPersonUpsertInput } from '../resource-operations.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
 /**
  * Individual-controller oriented facade over a `NodeRuntimeClient`.
@@ -75,6 +75,41 @@ export declare class IndividualControllerSdk {
      * Generates a digital twin projection from subject data.
      */
     generateDigitalTwinFromSubjectData(ctx: RouteContext, input: DigitalTwinGenerationInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches indexed clinical bundles for the current subject/controller context.
+     */
+    searchClinicalBundle(ctx: RouteContext, input: ClinicalBundleSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Returns the latest IPS-oriented bundle for one subject.
+     */
+    getLatestIps(ctx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes'>): Promise<SubmitAndPollResult>;
+    /**
+     * Searches subject/individual-side license seats using semantic filters.
+     */
+    searchLicenses(ctx: RouteContext, input: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists subject/individual-side license seats with optional filters.
+     */
+    listLicenses(ctx: RouteContext, input?: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches commercial license offers known for the individual/family
+     * context.
+     */
+    searchLicenseOffers(ctx: RouteContext, input: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists commercial license offers known for the individual/family context.
+     */
+    listLicenseOffers(ctx: RouteContext, input?: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Searches commercial license orders/payment projections for the
+     * individual/family context.
+     */
+    searchLicenseOrders(ctx: RouteContext, input: LicenseOrderRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists commercial license orders/payment projections for the
+     * individual/family context.
+     */
+    listLicenseOrders(ctx: RouteContext, input?: LicenseOrderRuntimeSearchInput): Promise<SubmitAndPollResult>;
     /**
      * Requests a SMART/OpenID token for subsequent data access flows.
      */

package/dist/orchestration/individual-controller-sdk.js

@@ -113,6 +113,57 @@ export class IndividualControllerSdk {
         assertFacadeCapability(this.capabilities, ActorCapabilities.IndividualGenerateDigitalTwin, ActorKinds.IndividualController, 'generateDigitalTwinFromSubjectData');
         return requireClientMethod(this.client, 'generateDigitalTwinFromSubjectData')(ctx, input);
     }
+    /**
+     * Searches indexed clinical bundles for the current subject/controller context.
+     */
+    searchClinicalBundle(ctx, input) {
+        return requireClientMethod(this.client, 'searchClinicalBundle')(ctx, input);
+    }
+    /**
+     * Returns the latest IPS-oriented bundle for one subject.
+     */
+    getLatestIps(ctx, input) {
+        return requireClientMethod(this.client, 'getLatestIps')(ctx, input);
+    }
+    /**
+     * Searches subject/individual-side license seats using semantic filters.
+     */
+    searchLicenses(ctx, input) {
+        return requireClientMethod(this.client, 'searchIndividualLicenses')(ctx, input);
+    }
+    /**
+     * Lists subject/individual-side license seats with optional filters.
+     */
+    listLicenses(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listIndividualLicenses')(ctx, input);
+    }
+    /**
+     * Searches commercial license offers known for the individual/family
+     * context.
+     */
+    searchLicenseOffers(ctx, input) {
+        return requireClientMethod(this.client, 'searchIndividualLicenseOffers')(ctx, input);
+    }
+    /**
+     * Lists commercial license offers known for the individual/family context.
+     */
+    listLicenseOffers(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listIndividualLicenseOffers')(ctx, input);
+    }
+    /**
+     * Searches commercial license orders/payment projections for the
+     * individual/family context.
+     */
+    searchLicenseOrders(ctx, input) {
+        return requireClientMethod(this.client, 'searchIndividualLicenseOrders')(ctx, input);
+    }
+    /**
+     * Lists commercial license orders/payment projections for the
+     * individual/family context.
+     */
+    listLicenseOrders(ctx, input = {}) {
+        return requireClientMethod(this.client, 'listIndividualLicenseOrders')(ctx, input);
+    }
     /**
      * Requests a SMART/OpenID token for subsequent data access flows.
      */