gdc-sdk-node-ts 0.9.1 → 2.0.2

package/dist/resource-operations.d.ts

@@ -1,3 +1,6 @@
+import { IndividualOrganizationLifecycleEditor } from 'gdc-common-utils-ts';
+import type { LicenseOfferSearchState, LicenseOrderSearchState } from 'gdc-common-utils-ts/utils/license-commercial-search';
+import type { LicenseListSearchState } from 'gdc-common-utils-ts/utils/license-list-search';
 import type { BundleSearchQuery, CommunicationInput, DateRange, EmployeeSearchValue } from 'gdc-sdk-core-ts';
 import type { SubmitAndPollResult } from './orchestration/client-port.js';
 import type { RouteContext } from './individual-onboarding.js';
@@ -59,6 +62,43 @@ export type OrganizationEmployeeSearchInput = {
         intervalMs?: number;
     };
 };
+/**
+ * Runtime search/list input for license seats exposed through actor facades.
+ *
+ * The semantic filter set comes from the shared license controller facade.
+ */
+export type LicenseListRuntimeSearchInput = {
+    licenseQuery?: Partial<LicenseListSearchState>;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+/**
+ * Runtime search/list input for commercial offer read-models exposed through
+ * actor facades.
+ */
+export type LicenseOfferRuntimeSearchInput = {
+    offerQuery?: Partial<LicenseOfferSearchState>;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+/**
+ * Runtime search/list input for commercial order/payment read-models exposed
+ * through actor facades.
+ */
+export type LicenseOrderRuntimeSearchInput = {
+    orderQuery?: Partial<LicenseOrderSearchState>;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
 /**
  * Current GW CORE individual/family lifecycle locator payload.
  *
@@ -71,7 +111,12 @@ export type IndividualOrganizationLifecycleInput = {
      * Canonical claims used by GW CORE to locate the hosted individual/family
      * registration.
      */
-    organizationClaims: Record<string, unknown>;
+    organizationClaims?: Record<string, unknown>;
+    /**
+     * Preferred high-level shared editor for lifecycle callers that want to
+     * avoid assembling raw claims inline.
+     */
+    organizationEditor?: IndividualOrganizationLifecycleEditor;
     /**
      * Optional canonical resource id when already known by the caller.
      */
@@ -122,6 +167,39 @@ export type CommunicationIngestionInput = {
         intervalMs?: number;
     };
 };
+/**
+ * Runtime participant query for `Communication/_search`.
+ *
+ * Search semantics:
+ * - `subject` scopes which individual communication sections to inspect
+ * - `userActorId` and `targetActorId` both match sender OR any recipient
+ * - `senderActorId` and `recipientActorId` constrain one side explicitly
+ * - `actorId` is the generic sender-or-recipient filter
+ * - `*` means "all" for the corresponding operand
+ *
+ * Canonical prefixes are normalized by shared `gdc-common-utils-ts` helpers:
+ * - `did:`
+ * - `email:` / `mailto:`
+ * - `tel:` / `phone:`
+ */
+export type CommunicationParticipantRuntimeSearchInput = {
+    searchParams?: Record<string, string | number | boolean | Array<string | number | boolean> | undefined>;
+    subject?: string | string[];
+    actorId?: string | string[];
+    senderActorId?: string | string[];
+    recipientActorId?: string | string[];
+    userActorId?: string | string[];
+    targetActorId?: string | string[];
+    periodStart?: string;
+    periodEnd?: string;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+    page?: number;
+    count?: number;
+};
 export type ClinicalDateRange = DateRange;
 export type ClinicalBundleSearchInput = Omit<BundleSearchQuery, 'section' | 'searchParams'> & {
     section?: string | string[];
@@ -255,6 +333,54 @@ export declare function searchOrganizationEmployeesWithDeps(routeCtx: RouteConte
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+/**
+ * Searches license seats for one organization/tenant through `License/_search`.
+ */
+export declare function searchOrganizationLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput, deps: {
+    organizationLicenseSearchPath: (ctx: RouteContext) => string;
+    organizationLicenseSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+/**
+ * Lists license seats using the same canonical `License/_search` route with no
+ * mandatory filters.
+ */
+export declare function listOrganizationLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput | undefined, deps: Parameters<typeof searchOrganizationLicensesWithDeps>[2]): Promise<SubmitAndPollResult>;
+/**
+ * Searches commercial license offers for one organization/tenant through
+ * `Offer/_search`.
+ */
+export declare function searchOrganizationLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput, deps: {
+    organizationLicenseOfferSearchPath: (ctx: RouteContext) => string;
+    organizationLicenseOfferSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listOrganizationLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput | undefined, deps: Parameters<typeof searchOrganizationLicenseOffersWithDeps>[2]): Promise<SubmitAndPollResult>;
+/**
+ * Searches commercial license orders/payment projections for one
+ * organization/tenant through `Order/_search`.
+ */
+export declare function searchOrganizationLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput, deps: {
+    organizationLicenseOrderSearchPath: (ctx: RouteContext) => string;
+    organizationLicenseOrderSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listOrganizationLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput | undefined, deps: Parameters<typeof searchOrganizationLicenseOrdersWithDeps>[2]): Promise<SubmitAndPollResult>;
 export declare function disableIndividualOrganizationWithDeps(routeCtx: RouteContext, input: IndividualOrganizationLifecycleInput, options: {
     timeoutMs?: number;
     intervalMs?: number;
@@ -281,6 +407,47 @@ export declare function purgeIndividualOrganizationWithDeps(routeCtx: RouteConte
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+/**
+ * Searches license seats for one individual/family controller context through
+ * the shared `License/_search` route.
+ */
+export declare function searchIndividualLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput, deps: {
+    individualLicenseSearchPath: (ctx: RouteContext) => string;
+    individualLicenseSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+/**
+ * Lists license seats for the individual/family side using the same canonical
+ * search route without mandatory filters.
+ */
+export declare function listIndividualLicensesWithDeps(routeCtx: RouteContext, input: LicenseListRuntimeSearchInput | undefined, deps: Parameters<typeof searchIndividualLicensesWithDeps>[2]): Promise<SubmitAndPollResult>;
+export declare function searchIndividualLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput, deps: {
+    individualLicenseOfferSearchPath: (ctx: RouteContext) => string;
+    individualLicenseOfferSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listIndividualLicenseOffersWithDeps(routeCtx: RouteContext, input: LicenseOfferRuntimeSearchInput | undefined, deps: Parameters<typeof searchIndividualLicenseOffersWithDeps>[2]): Promise<SubmitAndPollResult>;
+export declare function searchIndividualLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput, deps: {
+    individualLicenseOrderSearchPath: (ctx: RouteContext) => string;
+    individualLicenseOrderSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function listIndividualLicenseOrdersWithDeps(routeCtx: RouteContext, input: LicenseOrderRuntimeSearchInput | undefined, deps: Parameters<typeof searchIndividualLicenseOrdersWithDeps>[2]): Promise<SubmitAndPollResult>;
 export declare function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx: RouteContext, input: IpsOrFhirImportInput, deps: {
     individualCompositionR4BatchPath: (ctx: RouteContext) => string;
     individualCompositionR4PollPath: (ctx: RouteContext) => string;
@@ -291,6 +458,32 @@ export declare function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx: RouteCon
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+export declare function disableIndividualMemberWithDeps(routeCtx: RouteContext, input: IndividualMemberLifecycleInput, options: {
+    timeoutMs?: number;
+    intervalMs?: number;
+} | undefined, deps: {
+    individualRelatedPersonBatchPath: (ctx: RouteContext) => string;
+    individualRelatedPersonPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
+export declare function purgeIndividualMemberWithDeps(routeCtx: RouteContext, input: IndividualMemberLifecycleInput, options: {
+    timeoutMs?: number;
+    intervalMs?: number;
+} | undefined, deps: {
+    individualRelatedPersonPurgePath: (ctx: RouteContext) => string;
+    individualRelatedPersonPurgePollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
 export declare function upsertRelatedPersonAndPollWithDeps(routeCtx: RouteContext, input: RelatedPersonUpsertInput, deps: {
     individualRelatedPersonBatchPath: (ctx: RouteContext) => string;
     individualRelatedPersonPollPath: (ctx: RouteContext) => string;
@@ -312,6 +505,16 @@ export declare function ingestCommunicationAndUpdateIndexWithDeps(routeCtx: Rout
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+export declare function searchCommunicationParticipantsWithDeps(routeCtx: RouteContext, input: CommunicationParticipantRuntimeSearchInput, deps: {
+    communicationSearchPath: (ctx: RouteContext) => string;
+    communicationSearchPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
 export declare function searchClinicalBundleWithDeps(routeCtx: RouteContext, input: ClinicalBundleSearchInput, deps: {
     bundleSearchPath: (ctx: RouteContext) => string;
     bundleSearchPollPath: (ctx: RouteContext) => string;

package/dist/resource-operations.js

@@ -1,5 +1,8 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { HealthcareBasicSections } from 'gdc-common-utils-ts/constants';
+import { HealthcareBasicSections, ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants';
+import { Format } from 'gdc-common-utils-ts/constants/Schemas';
+import { RelatedPersonClaim } from 'gdc-common-utils-ts/models/interoperable-claims/related-person-claims';
+import { buildCommunicationParticipantSearchBundle, createInteroperableResourceOperationEditor, IndividualOrganizationLifecycleEditor, LicenseOfferSearchEditor, LicenseOrderSearchEditor, InteroperableLifecycleStatuses, LicenseListSearchEditor, } from 'gdc-common-utils-ts';
 import { GwCoreLifecycleRequestMethod, GwCoreLifecycleRequestType, GwCoreLifecycleTodo, } from './constants/lifecycle.js';
 import { buildEmployeeBatchEntry, buildEmployeeSearchBundle, } from 'gdc-sdk-core-ts';
 export async function createOrganizationEmployeeWithDeps(routeCtx, input, options, deps) {
@@ -43,6 +46,69 @@ export async function searchOrganizationEmployeesWithDeps(routeCtx, input, deps)
         body: buildEmployeeSearchBundle({ claims: input.employeeClaims }),
     }, input.pollOptions);
 }
+/**
+ * Searches license seats for one organization/tenant through `License/_search`.
+ */
+export async function searchOrganizationLicensesWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.organizationLicenseSearchPath(routeCtx), deps.organizationLicenseSearchPollPath(routeCtx), {
+        thid: input.requestThid || `organization-license-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [
+                new LicenseListSearchEditor(input.licenseQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+/**
+ * Lists license seats using the same canonical `License/_search` route with no
+ * mandatory filters.
+ */
+export async function listOrganizationLicensesWithDeps(routeCtx, input, deps) {
+    return searchOrganizationLicensesWithDeps(routeCtx, input || {}, deps);
+}
+/**
+ * Searches commercial license offers for one organization/tenant through
+ * `Offer/_search`.
+ */
+export async function searchOrganizationLicenseOffersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.organizationLicenseOfferSearchPath(routeCtx), deps.organizationLicenseOfferSearchPollPath(routeCtx), {
+        thid: input.requestThid || `organization-license-offer-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOfferSearchEditor(input.offerQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listOrganizationLicenseOffersWithDeps(routeCtx, input, deps) {
+    return searchOrganizationLicenseOffersWithDeps(routeCtx, input || {}, deps);
+}
+/**
+ * Searches commercial license orders/payment projections for one
+ * organization/tenant through `Order/_search`.
+ */
+export async function searchOrganizationLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.organizationLicenseOrderSearchPath(routeCtx), deps.organizationLicenseOrderSearchPollPath(routeCtx), {
+        thid: input.requestThid || `organization-license-order-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOrderSearchEditor(input.orderQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listOrganizationLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return searchOrganizationLicenseOrdersWithDeps(routeCtx, input || {}, deps);
+}
 export async function disableIndividualOrganizationWithDeps(routeCtx, input, options, deps) {
     // TODO(gw-core-lifecycle-target-patch-individual-disable): migrate from
     // explicit `_disable` to `_batch + PATCH` only after GW CORE supports it.
@@ -51,6 +117,7 @@ export async function disableIndividualOrganizationWithDeps(routeCtx, input, opt
         routeCtx,
         requestType: input.dataType || GwCoreLifecycleRequestType.IndividualOrganizationDisable,
         organizationClaims: input.organizationClaims,
+        organizationEditor: input.organizationEditor,
         resourceId: input.resourceId,
         thidPrefix: 'individual-organization-disable',
     });
@@ -61,11 +128,68 @@ export async function purgeIndividualOrganizationWithDeps(routeCtx, input, optio
         routeCtx,
         requestType: input.dataType || GwCoreLifecycleRequestType.IndividualOrganizationPurge,
         organizationClaims: input.organizationClaims,
+        organizationEditor: input.organizationEditor,
         resourceId: input.resourceId,
         thidPrefix: 'individual-organization-purge',
     });
     return deps.submitAndPoll(deps.individualOrganizationPurgePath(routeCtx), deps.individualOrganizationPurgePollPath(routeCtx), payload, options);
 }
+/**
+ * Searches license seats for one individual/family controller context through
+ * the shared `License/_search` route.
+ */
+export async function searchIndividualLicensesWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.individualLicenseSearchPath(routeCtx), deps.individualLicenseSearchPollPath(routeCtx), {
+        thid: input.requestThid || `individual-license-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [
+                new LicenseListSearchEditor(input.licenseQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+/**
+ * Lists license seats for the individual/family side using the same canonical
+ * search route without mandatory filters.
+ */
+export async function listIndividualLicensesWithDeps(routeCtx, input, deps) {
+    return searchIndividualLicensesWithDeps(routeCtx, input || {}, deps);
+}
+export async function searchIndividualLicenseOffersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.individualLicenseOfferSearchPath(routeCtx), deps.individualLicenseOfferSearchPollPath(routeCtx), {
+        thid: input.requestThid || `individual-license-offer-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOfferSearchEditor(input.offerQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listIndividualLicenseOffersWithDeps(routeCtx, input, deps) {
+    return searchIndividualLicenseOffersWithDeps(routeCtx, input || {}, deps);
+}
+export async function searchIndividualLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.individualLicenseOrderSearchPath(routeCtx), deps.individualLicenseOrderSearchPollPath(routeCtx), {
+        thid: input.requestThid || `individual-license-order-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOrderSearchEditor(input.orderQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listIndividualLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return searchIndividualLicenseOrdersWithDeps(routeCtx, input || {}, deps);
+}
 export async function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx, input, deps) {
     const payload = {
         thid: input.compositionPayload.thid || `composition-${createRuntimeUuid()}`,
@@ -79,6 +203,65 @@ export async function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx, input, dep
         : deps.individualCompositionR4PollPath(routeCtx);
     return deps.submitAndPoll(submitPath, pollPath, payload, input.pollOptions);
 }
+export async function disableIndividualMemberWithDeps(routeCtx, input, options, deps) {
+    const claims = {
+        '@context': String(input.memberClaims?.['@context'] || Format.FHIR_API).trim() || Format.FHIR_API,
+        ...(input.memberClaims || {}),
+    };
+    const resource = createInteroperableResourceOperationEditor()
+        .setResourceType(ResourceTypesFhirR4.RelatedPerson)
+        .setIdentifierClaimKey(RelatedPersonClaim.IdentifierValue)
+        .setBusinessIdentifier(String(claims[RelatedPersonClaim.IdentifierValue] || claims[RelatedPersonClaim.Identifier] || '').trim())
+        .setClaims(claims)
+        .setLifecycleStatus(InteroperableLifecycleStatuses.Inactive)
+        .buildLifecycleResource();
+    const payload = {
+        thid: `relatedperson-disable-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [{
+                    request: { method: GwCoreLifecycleRequestMethod.Post },
+                    meta: { claims },
+                    resource: {
+                        ...resource,
+                        ...(input.resourceId ? { id: input.resourceId } : {}),
+                    },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.individualRelatedPersonBatchPath(routeCtx), deps.individualRelatedPersonPollPath(routeCtx), payload, options);
+}
+export async function purgeIndividualMemberWithDeps(routeCtx, input, options, deps) {
+    const claims = {
+        '@context': String(input.memberClaims?.['@context'] || Format.FHIR_API).trim() || Format.FHIR_API,
+        ...(input.memberClaims || {}),
+    };
+    const resource = createInteroperableResourceOperationEditor()
+        .setResourceType(ResourceTypesFhirR4.RelatedPerson)
+        .setIdentifierClaimKey(RelatedPersonClaim.IdentifierValue)
+        .setBusinessIdentifier(String(claims[RelatedPersonClaim.IdentifierValue] || claims[RelatedPersonClaim.Identifier] || '').trim())
+        .setClaims(claims)
+        .setLifecycleStatus(InteroperableLifecycleStatuses.Purged)
+        .buildLifecycleResource();
+    const payload = {
+        thid: `relatedperson-purge-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [{
+                    type: input.dataType || GwCoreLifecycleRequestType.IndividualMemberPurge,
+                    request: { method: GwCoreLifecycleRequestMethod.Post },
+                    meta: { claims },
+                    resource: {
+                        ...resource,
+                        ...(input.resourceId ? { id: input.resourceId } : {}),
+                    },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.individualRelatedPersonPurgePath(routeCtx), deps.individualRelatedPersonPurgePollPath(routeCtx), payload, options);
+}
 export async function upsertRelatedPersonAndPollWithDeps(routeCtx, input, deps) {
     const payload = {
         thid: input.relatedPersonPayload.thid || `relatedperson-${createRuntimeUuid()}`,
@@ -99,6 +282,25 @@ export async function ingestCommunicationAndUpdateIndexWithDeps(routeCtx, input,
         : payload;
     return deps.submitAndPoll(deps.individualCommunicationBatchPath(routeCtx, pathFormatSegment), deps.individualCommunicationPollPath(routeCtx, pathFormatSegment), convertedPayload, input.pollOptions);
 }
+export async function searchCommunicationParticipantsWithDeps(routeCtx, input, deps) {
+    const payload = {
+        thid: input.requestThid || `communication-search-${createRuntimeUuid()}`,
+        body: buildCommunicationParticipantSearchBundle({
+            searchParams: input.searchParams,
+            subject: input.subject,
+            actorId: input.actorId,
+            senderActorId: input.senderActorId,
+            recipientActorId: input.recipientActorId,
+            userActorId: input.userActorId,
+            targetActorId: input.targetActorId,
+            periodStart: input.periodStart,
+            periodEnd: input.periodEnd,
+            page: input.page,
+            count: input.count,
+        }),
+    };
+    return deps.submitAndPoll(deps.communicationSearchPath(routeCtx), deps.communicationSearchPollPath(routeCtx), payload, input.pollOptions);
+}
 export async function searchClinicalBundleWithDeps(routeCtx, input, deps) {
     const query = buildBundleSearchQuery(input);
     const payload = {
@@ -203,24 +405,21 @@ function buildEmployeeLifecyclePayload(input) {
     };
 }
 function buildIndividualOrganizationLifecyclePayload(input) {
-    const claims = input.organizationClaims || {};
+    const payload = input.organizationEditor
+        ? new IndividualOrganizationLifecycleEditor(input.organizationEditor.getState())
+        : new IndividualOrganizationLifecycleEditor().setClaims(input.organizationClaims || {});
+    payload
+        .setRequestType(input.requestType)
+        .setThreadId(`${input.thidPrefix}-${createRuntimeUuid()}`);
+    if (input.resourceId) {
+        payload.setResourceId(input.resourceId);
+    }
     return {
         jti: `jti-${createRuntimeUuid()}`,
         iss: input.routeCtx.tenantId,
         aud: input.routeCtx.tenantId,
         type: 'application/didcomm-plain+json',
-        thid: `${input.thidPrefix}-${createRuntimeUuid()}`,
-        body: {
-            data: [{
-                    type: input.requestType,
-                    request: { method: GwCoreLifecycleRequestMethod.Post },
-                    meta: { claims },
-                    resource: {
-                        ...(input.resourceId ? { id: input.resourceId } : {}),
-                        meta: { claims },
-                    },
-                }],
-        },
+        ...payload.buildCurrentGwPayload(),
     };
 }
 function buildBundleSearchQuery(input) {

package/dist/session.js

@@ -30,7 +30,7 @@ export class ActorSession {
     }
     asHostOnboarding() {
         this.assertActorKind(ActorKinds.HostOnboarding);
-        return new HostOnboardingSdk(this.requireClient());
+        return new HostOnboardingSdk(this.requireClient(), this.capabilities);
     }
     asOrganizationController() {
         this.assertActorKind(ActorKinds.OrganizationController);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "0.9.1",
+  "version": "2.0.2",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -13,12 +13,25 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "type-check": "tsc -p tsconfig.json --noEmit",
+    "local:close": "PORTS=3000 bash ./scripts/local-close.sh",
+    "docker:close": "PORTS=8000 bash ./scripts/local-close.sh",
     "test": "npm run build && node --test tests/*.test.mjs",
-    "test:e2e:live-gw": "npm run build && RUN_LIVE_GW_E2E=1 node --test tests/live-gw-node-runtime.e2e.test.mjs"
+    "test:e2e:live-gw": "npm run build && RUN_LIVE_GW_E2E=1 node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:professional": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_SUITE=professional node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:individual": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_SUITE=individual node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:clinical": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_SUITE=clinical node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:didcomm-plain": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_TRANSPORT=didcomm-plain node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:legacy-fhir": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_TRANSPORT=legacy-fhir node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:all": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_TRANSPORT=all node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:host-transaction:clean": "bash ./scripts/run-live-gw-host-transaction-clean.sh",
+    "test:e2e:live-profile-runtime:individual": "npm run build && RUN_LIVE_PROFILE_RUNTIME_E2E=1 node --test tests/live-profile-runtime-individual.e2e.test.mjs",
+    "test:e2e:live-profile-runtime:professional": "npm run build && RUN_LIVE_PROFILE_RUNTIME_PROFESSIONAL_E2E=1 node --test tests/live-profile-runtime-professional.e2e.test.mjs",
+    "test:e2e:live-dialogue:consent-professional": "npm run build && RUN_LIVE_DIALOGUE_CONSENT_PROFESSIONAL_E2E=1 node --test tests/live-dialogue-consent-professional-access.e2e.test.mjs",
+    "test:e2e:live-gw:clean": "bash ./scripts/run-live-gw-clean.sh"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "^1.20.1",
-    "gdc-sdk-core-ts": "^0.9.1"
+    "gdc-common-utils-ts": "^2.0.4",
+    "gdc-sdk-core-ts": "^2.0.3"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",