gdc-sdk-node-ts 0.12.0 → 2.0.4

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

@@ -0,0 +1,65 @@
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import type { ProfileLoadRequest } from 'gdc-sdk-core-ts';
+import type { LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput, OrganizationEmployeeCreationInput, OrganizationEmployeeLifecycleInput, OrganizationEmployeeSearchInput } from './resource-operations.js';
+import type { HostRouteContext, HostedTenantLifecycleInput } from './host-onboarding.js';
+import type { OrganizationLicenseOrderConfirmInput } from './organization-license-order.js';
+import type { RouteContext } from './individual-onboarding.js';
+import { type BackendOrganizationControllerProfile, type BackendProfileRuntimeClient } from './backend-profile-runtime.js';
+/**
+ * Backend use-case facade for the organization-controller happy path.
+ *
+ * This wrapper keeps the step-by-step tutorial surface high-level for:
+ * - license seat discovery
+ * - employee provisioning and lifecycle
+ * - tenant disable/purge cleanup
+ */
+export declare class OrganizationControllerBackendRuntime {
+    private readonly profileRuntime;
+    constructor(profileRuntime: BackendProfileRuntimeClient);
+    /**
+     * Loads one organization-controller backend profile and materializes its
+     * actor facade in one step.
+     */
+    loadProfile(input: ProfileLoadRequest): Promise<BackendOrganizationControllerProfile>;
+    /**
+     * Lists organization-owned license seats.
+     */
+    listLicenses(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input?: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists commercial offers available to contract more seats.
+     */
+    listLicenseOffers(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input?: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists already-created commercial orders.
+     */
+    listLicenseOrders(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input?: LicenseOrderRuntimeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Confirms one already-paid organization order so additional seats become
+     * usable by employees.
+     */
+    confirmOrganizationLicenseOrder(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input: OrganizationLicenseOrderConfirmInput): Promise<SubmitAndPollResult>;
+    /**
+     * Creates one employee under the current tenant.
+     */
+    createEmployee(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input: OrganizationEmployeeCreationInput): Promise<SubmitAndPollResult>;
+    /**
+     * Lists/searches employees under the current tenant.
+     */
+    searchEmployees(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input: OrganizationEmployeeSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Disables one employee without purging it yet.
+     */
+    disableEmployee(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input: OrganizationEmployeeLifecycleInput): Promise<SubmitAndPollResult>;
+    /**
+     * Purges one already-disabled employee.
+     */
+    purgeEmployee(profile: BackendOrganizationControllerProfile, ctx: RouteContext, input: OrganizationEmployeeLifecycleInput): Promise<SubmitAndPollResult>;
+    /**
+     * Disables the tenant after dependent actors have been disabled.
+     */
+    disableTenant(profile: BackendOrganizationControllerProfile, hostCtx: HostRouteContext, input: HostedTenantLifecycleInput): Promise<SubmitAndPollResult>;
+    /**
+     * Purges the tenant after employee and individual cleanup.
+     */
+    purgeTenant(profile: BackendOrganizationControllerProfile, hostCtx: HostRouteContext, input: HostedTenantLifecycleInput): Promise<SubmitAndPollResult>;
+}

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

@@ -0,0 +1,83 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { loadBackendOrganizationControllerProfile, } from './backend-profile-runtime.js';
+/**
+ * Backend use-case facade for the organization-controller happy path.
+ *
+ * This wrapper keeps the step-by-step tutorial surface high-level for:
+ * - license seat discovery
+ * - employee provisioning and lifecycle
+ * - tenant disable/purge cleanup
+ */
+export class OrganizationControllerBackendRuntime {
+    constructor(profileRuntime) {
+        this.profileRuntime = profileRuntime;
+    }
+    /**
+     * Loads one organization-controller backend profile and materializes its
+     * actor facade in one step.
+     */
+    loadProfile(input) {
+        return loadBackendOrganizationControllerProfile(this.profileRuntime, input);
+    }
+    /**
+     * Lists organization-owned license seats.
+     */
+    listLicenses(profile, ctx, input = {}) {
+        return profile.sdk.listLicenses(ctx, input);
+    }
+    /**
+     * Lists commercial offers available to contract more seats.
+     */
+    listLicenseOffers(profile, ctx, input = {}) {
+        return profile.sdk.listLicenseOffers(ctx, input);
+    }
+    /**
+     * Lists already-created commercial orders.
+     */
+    listLicenseOrders(profile, ctx, input = {}) {
+        return profile.sdk.listLicenseOrders(ctx, input);
+    }
+    /**
+     * Confirms one already-paid organization order so additional seats become
+     * usable by employees.
+     */
+    confirmOrganizationLicenseOrder(profile, ctx, input) {
+        return profile.sdk.confirmOrganizationLicenseOrder(ctx, input);
+    }
+    /**
+     * Creates one employee under the current tenant.
+     */
+    createEmployee(profile, ctx, input) {
+        return profile.sdk.createOrganizationEmployee(ctx, input);
+    }
+    /**
+     * Lists/searches employees under the current tenant.
+     */
+    searchEmployees(profile, ctx, input) {
+        return profile.sdk.searchOrganizationEmployees(ctx, input);
+    }
+    /**
+     * Disables one employee without purging it yet.
+     */
+    disableEmployee(profile, ctx, input) {
+        return profile.sdk.disableEmployee(ctx, input);
+    }
+    /**
+     * Purges one already-disabled employee.
+     */
+    purgeEmployee(profile, ctx, input) {
+        return profile.sdk.purgeEmployee(ctx, input);
+    }
+    /**
+     * Disables the tenant after dependent actors have been disabled.
+     */
+    disableTenant(profile, hostCtx, input) {
+        return profile.sdk.disableTenant(hostCtx, input);
+    }
+    /**
+     * Purges the tenant after employee and individual cleanup.
+     */
+    purgeTenant(profile, hostCtx, input) {
+        return profile.sdk.purgeTenant(hostCtx, input);
+    }
+}

package/dist/professional-backend-runtime.d.ts

@@ -0,0 +1,36 @@
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import type { ProfileLoadRequest } from 'gdc-sdk-core-ts';
+import type { RouteContext } from './individual-onboarding.js';
+import type { SmartTokenExchangeResult, SmartTokenRequestInput } from './smart-token.js';
+import type { ClinicalBundleSearchInput } from './resource-operations.js';
+import { type BackendProfessionalProfile, type BackendProfileRuntimeClient } from './backend-profile-runtime.js';
+/**
+ * Backend use-case facade for the current professional happy path.
+ *
+ * This mirrors the individual-controller runtime wrapper, but for the actor
+ * that:
+ * - loads one protected professional profile,
+ * - requests one SMART token,
+ * - reads one authorized clinical bundle or latest IPS bundle.
+ */
+export declare class ProfessionalBackendRuntime {
+    private readonly profileRuntime;
+    constructor(profileRuntime: BackendProfileRuntimeClient);
+    /**
+     * Loads one professional backend profile and materializes its actor facade in
+     * one step.
+     */
+    loadProfile(input: ProfileLoadRequest): Promise<BackendProfessionalProfile>;
+    /**
+     * Requests one SMART/OpenID token from the professional actor facade.
+     */
+    requestSmartToken(profile: BackendProfessionalProfile, input: SmartTokenRequestInput): Promise<SmartTokenExchangeResult>;
+    /**
+     * Searches one authorized clinical bundle through the professional facade.
+     */
+    searchClinicalBundle(profile: BackendProfessionalProfile, ctx: RouteContext, input: ClinicalBundleSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Reads the latest IPS-oriented bundle through the professional facade.
+     */
+    getLatestIps(profile: BackendProfessionalProfile, ctx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes'>): Promise<SubmitAndPollResult>;
+}

package/dist/professional-backend-runtime.js

@@ -0,0 +1,41 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { loadBackendProfessionalProfile, } from './backend-profile-runtime.js';
+/**
+ * Backend use-case facade for the current professional happy path.
+ *
+ * This mirrors the individual-controller runtime wrapper, but for the actor
+ * that:
+ * - loads one protected professional profile,
+ * - requests one SMART token,
+ * - reads one authorized clinical bundle or latest IPS bundle.
+ */
+export class ProfessionalBackendRuntime {
+    constructor(profileRuntime) {
+        this.profileRuntime = profileRuntime;
+    }
+    /**
+     * Loads one professional backend profile and materializes its actor facade in
+     * one step.
+     */
+    loadProfile(input) {
+        return loadBackendProfessionalProfile(this.profileRuntime, input);
+    }
+    /**
+     * Requests one SMART/OpenID token from the professional actor facade.
+     */
+    requestSmartToken(profile, input) {
+        return profile.sdk.requestSmartToken(input);
+    }
+    /**
+     * Searches one authorized clinical bundle through the professional facade.
+     */
+    searchClinicalBundle(profile, ctx, input) {
+        return profile.sdk.searchClinicalBundle(ctx, input);
+    }
+    /**
+     * Reads the latest IPS-oriented bundle through the professional facade.
+     */
+    getLatestIps(profile, ctx, input) {
+        return profile.sdk.getLatestIps(ctx, input);
+    }
+}

package/dist/profile-workspace.d.ts

@@ -0,0 +1,82 @@
+import { CommunicationAttachedBundleSession, IndividualBundleVault, buildVitalSignObservationClaims, createSummaryOperationRequestParameters, createSummaryOperationRequestParametersResource, summarizeClinicalBundle, toClinicalResourceExpandedViews, type BuildVitalSignObservationClaimsInput } from 'gdc-common-utils-ts';
+import type { BackendOrganizationControllerProfile, BackendProfessionalProfile } from './backend-profile-runtime.js';
+export type IpsRequestDraft = Readonly<{
+    subjectId: string;
+    purpose?: string;
+    sectionList: readonly string[];
+    summaryOperationRequestParameters: ReturnType<typeof createSummaryOperationRequestParameters>;
+    summaryOperationRequestReferencePath: string;
+    summaryOperationRequestParametersResource: ReturnType<typeof createSummaryOperationRequestParametersResource>;
+}>;
+export type ProcessedClinicalBundleResponse = Readonly<{
+    totalErrors: number;
+    totalSections: number;
+    totalResources: number;
+    totalResourcesInSection: Readonly<Record<string, number>>;
+    totalNarratives: number;
+    totalNotes: number;
+    summary: ReturnType<typeof summarizeClinicalBundle>;
+    views: ReturnType<typeof toClinicalResourceExpandedViews>;
+}>;
+declare function buildProcessedClinicalBundleResponse(body: unknown): ProcessedClinicalBundleResponse;
+declare class ProfessionalSubjectIpsWorkspace {
+    private readonly subjectId;
+    private readonly bundleVault;
+    constructor(subjectId: string, bundleVault: IndividualBundleVault);
+    prepareRequestBundleIps: {
+        new: (sectionList?: readonly string[], purpose?: string) => IpsRequestDraft;
+    };
+    processResponseBundleIps(body: unknown): ProcessedClinicalBundleResponse;
+    rememberResponseBundleIps(body: unknown): Promise<IndividualBundleVault>;
+    addVitalSign(input: BuildVitalSignObservationClaimsInput): Promise<IndividualBundleVault>;
+    get cache(): IndividualBundleVault;
+}
+declare class ProfessionalSubjectWorkspace {
+    private readonly profile;
+    private readonly cacheBySubject;
+    constructor(profile: BackendProfessionalProfile, cacheBySubject?: Map<string, IndividualBundleVault>);
+    use(subjectId: string): Promise<ProfessionalSubjectIpsWorkspace>;
+}
+export declare class ProfessionalProfileWorkspace {
+    readonly profile: BackendProfessionalProfile;
+    readonly subject: ProfessionalSubjectWorkspace;
+    constructor(profile: BackendProfessionalProfile);
+}
+export declare class OrganizationControllerProfileWorkspace {
+    readonly profile: BackendOrganizationControllerProfile;
+    readonly organization: {
+        bundleEditor: {
+            consentTemplate: (initialBundle?: Record<string, any>) => import("gdc-common-utils-ts").ConsentAccessEditor;
+            invoice: () => import("gdc-common-utils-ts").InvoiceBundleEditor;
+            clinicalCommunication: (initialBundle?: Record<string, any>, communicationClaims?: Record<string, unknown>) => CommunicationAttachedBundleSession;
+        };
+        employee: {
+            processResponseDirectory: (body: unknown) => Readonly<{
+                identifier?: string;
+                email?: string;
+                role?: string;
+                worksFor?: string;
+                memberOf?: string;
+                memberOfOrgTaxId?: string;
+                resourceId?: string;
+                status?: string;
+                claims: Record<string, unknown>;
+            }>[];
+        };
+        license: {
+            processResponseList: (body: unknown) => Readonly<{
+                contracted: number;
+                free: number;
+                used: number;
+                available: number;
+                issued: number;
+                active: number;
+                inactive: number;
+            }>;
+        };
+    };
+    constructor(profile: BackendOrganizationControllerProfile);
+}
+export declare function createProfessionalProfileWorkspace(profile: BackendProfessionalProfile): ProfessionalProfileWorkspace;
+export declare function createOrganizationControllerProfileWorkspace(profile: BackendOrganizationControllerProfile): OrganizationControllerProfileWorkspace;
+export { buildProcessedClinicalBundleResponse, buildVitalSignObservationClaims, };

package/dist/profile-workspace.js

@@ -0,0 +1,127 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { CommunicationAttachedBundleSession, IndividualBundleVault, VaultMemRepository, buildVitalSignObservationClaims, createConsentAccessEditor, createInvoiceBundleEditor, createSummaryOperationRequestParameters, createSummaryOperationRequestParametersResource, createSummaryOperationRequestReferencePath, readEmployeeSearchResults, summarizeClinicalBundle, summarizeLicenseListRecords, toClinicalResourceExpandedViews, } from 'gdc-common-utils-ts';
+function normalizeSectionList(sectionList) {
+    return Array.from(new Set((sectionList || []).map((item) => String(item || '').trim()).filter(Boolean)));
+}
+function unwrapBody(body) {
+    const root = body && typeof body === 'object' ? body : {};
+    return root.body && typeof root.body === 'object' ? root.body : root;
+}
+function buildClinicalSectionCounts(views) {
+    const out = {};
+    for (const view of views) {
+        const sections = String(view.common.claims['Composition.section'] || '').split(',').map((item) => item.trim()).filter(Boolean);
+        if (sections.length === 0) {
+            out.unknown = (out.unknown || 0) + 1;
+            continue;
+        }
+        for (const section of sections) {
+            out[section] = (out[section] || 0) + 1;
+        }
+    }
+    return out;
+}
+function buildProcessedClinicalBundleResponse(body) {
+    const bundle = unwrapBody(body);
+    const views = toClinicalResourceExpandedViews(bundle);
+    const summary = summarizeClinicalBundle(bundle);
+    return {
+        totalErrors: 0,
+        totalSections: Object.keys(buildClinicalSectionCounts(views)).length,
+        totalResources: summary.totalEntries,
+        totalResourcesInSection: buildClinicalSectionCounts(views),
+        totalNarratives: summary.xhtmlEntries,
+        totalNotes: summary.notedEntries,
+        summary,
+        views,
+    };
+}
+class ProfessionalSubjectIpsWorkspace {
+    constructor(subjectId, bundleVault) {
+        this.subjectId = subjectId;
+        this.bundleVault = bundleVault;
+        this.prepareRequestBundleIps = {
+            new: (sectionList, purpose) => {
+                const normalizedSections = normalizeSectionList(sectionList);
+                const summaryOperationRequestParameters = createSummaryOperationRequestParameters({
+                    subjectId: this.subjectId,
+                    filterSections: normalizedSections,
+                });
+                return {
+                    subjectId: this.subjectId,
+                    purpose: typeof purpose === 'string' && purpose.trim() ? purpose.trim() : undefined,
+                    sectionList: normalizedSections,
+                    summaryOperationRequestParameters,
+                    summaryOperationRequestReferencePath: createSummaryOperationRequestReferencePath(summaryOperationRequestParameters),
+                    summaryOperationRequestParametersResource: createSummaryOperationRequestParametersResource(summaryOperationRequestParameters),
+                };
+            },
+        };
+    }
+    processResponseBundleIps(body) {
+        return buildProcessedClinicalBundleResponse(body);
+    }
+    async rememberResponseBundleIps(body) {
+        await this.bundleVault.importBundleDocument(unwrapBody(body));
+        return this.bundleVault;
+    }
+    async addVitalSign(input) {
+        await this.bundleVault.upsertVitalSign(input);
+        return this.bundleVault;
+    }
+    get cache() {
+        return this.bundleVault;
+    }
+}
+class ProfessionalSubjectWorkspace {
+    constructor(profile, cacheBySubject = new Map()) {
+        this.profile = profile;
+        this.cacheBySubject = cacheBySubject;
+    }
+    async use(subjectId) {
+        const normalizedSubjectId = String(subjectId || '').trim() || String(this.profile.profile.descriptor.subjectDid || '').trim();
+        let bundleVault = this.cacheBySubject.get(normalizedSubjectId);
+        if (!bundleVault) {
+            bundleVault = await new IndividualBundleVault({
+                vaultRepository: new VaultMemRepository(),
+                individualId: normalizedSubjectId,
+            }).initialize();
+            this.cacheBySubject.set(normalizedSubjectId, bundleVault);
+        }
+        return new ProfessionalSubjectIpsWorkspace(normalizedSubjectId, bundleVault);
+    }
+}
+export class ProfessionalProfileWorkspace {
+    constructor(profile) {
+        this.profile = profile;
+        this.subject = new ProfessionalSubjectWorkspace(profile);
+    }
+}
+export class OrganizationControllerProfileWorkspace {
+    constructor(profile) {
+        this.profile = profile;
+        this.organization = {
+            bundleEditor: {
+                consentTemplate: (initialBundle) => createConsentAccessEditor(initialBundle ? { initialBundle: initialBundle } : undefined),
+                invoice: () => createInvoiceBundleEditor(),
+                clinicalCommunication: (initialBundle, communicationClaims) => new CommunicationAttachedBundleSession({
+                    ...(initialBundle ? { initialBundle: initialBundle } : {}),
+                    ...(communicationClaims ? { communicationClaims } : {}),
+                }),
+            },
+            employee: {
+                processResponseDirectory: (body) => readEmployeeSearchResults(body),
+            },
+            license: {
+                processResponseList: (body) => summarizeLicenseListRecords(body),
+            },
+        };
+    }
+}
+export function createProfessionalProfileWorkspace(profile) {
+    return new ProfessionalProfileWorkspace(profile);
+}
+export function createOrganizationControllerProfileWorkspace(profile) {
+    return new OrganizationControllerProfileWorkspace(profile);
+}
+export { buildProcessedClinicalBundleResponse, buildVitalSignObservationClaims, };

package/dist/resource-operations.d.ts

@@ -1,4 +1,6 @@
-import { type LicenseOfferSearchDraft, type LicenseOrderSearchDraft, type LicenseListSearchDraft } from 'gdc-common-utils-ts';
+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';
@@ -66,7 +68,7 @@ export type OrganizationEmployeeSearchInput = {
  * The semantic filter set comes from the shared license controller facade.
  */
 export type LicenseListRuntimeSearchInput = {
-    licenseQuery?: Partial<LicenseListSearchDraft>;
+    licenseQuery?: Partial<LicenseListSearchState>;
     requestThid?: string;
     pollOptions?: {
         timeoutMs?: number;
@@ -78,7 +80,7 @@ export type LicenseListRuntimeSearchInput = {
  * actor facades.
  */
 export type LicenseOfferRuntimeSearchInput = {
-    offerQuery?: Partial<LicenseOfferSearchDraft>;
+    offerQuery?: Partial<LicenseOfferSearchState>;
     requestThid?: string;
     pollOptions?: {
         timeoutMs?: number;
@@ -90,7 +92,7 @@ export type LicenseOfferRuntimeSearchInput = {
  * through actor facades.
  */
 export type LicenseOrderRuntimeSearchInput = {
-    orderQuery?: Partial<LicenseOrderSearchDraft>;
+    orderQuery?: Partial<LicenseOrderSearchState>;
     requestThid?: string;
     pollOptions?: {
         timeoutMs?: number;
@@ -109,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.
      */
@@ -160,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[];
@@ -234,6 +274,20 @@ export type GrantProfessionalAccessResult = {
     consentClaims: Record<string, unknown>;
     claimsCid?: string;
 };
+export type RevokeProfessionalAccessInput = {
+    consentClaims: Record<string, unknown>;
+    periodEnd?: string;
+    dataType?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+export type RevokeProfessionalAccessResult = {
+    thid: string;
+    consent: SubmitAndPollResult;
+    consentClaims: Record<string, unknown>;
+};
 export type DigitalTwinGenerationInput = {
     compositionPayload: {
         thid?: string;
@@ -465,6 +519,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;
@@ -498,6 +562,16 @@ export declare function grantProfessionalAccessWithDeps(routeCtx: RouteContext,
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<GrantProfessionalAccessResult>;
+export declare function revokeProfessionalAccessWithDeps(routeCtx: RouteContext, input: RevokeProfessionalAccessInput, deps: {
+    individualConsentR4BatchPath: (ctx: RouteContext) => string;
+    individualConsentR4PollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<RevokeProfessionalAccessResult>;
 export declare function generateDigitalTwinFromSubjectDataWithDeps(routeCtx: RouteContext, input: DigitalTwinGenerationInput, deps: {
     digitalTwinCompositionApiBatchPath: (ctx: RouteContext) => string;
     digitalTwinCompositionApiPollPath: (ctx: RouteContext) => string;

package/dist/resource-operations.js

@@ -2,9 +2,9 @@
 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 { createInteroperableResourceOperationEditor, IndividualOrganizationLifecycleDraft, LicenseOfferSearchEditor, LicenseOrderSearchEditor, InteroperableLifecycleStatuses, LicenseListSearchEditor, } from 'gdc-common-utils-ts';
+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';
+import { buildEmployeeBatchEntry, buildEmployeeSearchBundle, ConsentClaims, } from 'gdc-sdk-core-ts';
 export async function createOrganizationEmployeeWithDeps(routeCtx, input, options, deps) {
     const payload = buildEmployeeLifecyclePayload({
         routeCtx,
@@ -117,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',
     });
@@ -127,6 +128,7 @@ 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',
     });
@@ -280,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 = {
@@ -337,6 +358,29 @@ export async function grantProfessionalAccessWithDeps(routeCtx, input, deps) {
         claimsCid: built.claimsCid,
     };
 }
+export async function revokeProfessionalAccessWithDeps(routeCtx, input, deps) {
+    const revokedClaims = ConsentClaims
+        .fromClaims(input.consentClaims)
+        .setPeriodEnd(String(input.periodEnd || new Date().toISOString()).trim())
+        .toClaims();
+    const thid = `consent-revoke-${createRuntimeUuid()}`;
+    const consentPayload = {
+        thid,
+        body: {
+            data: [{
+                    type: input.dataType || 'Consent-grant-request-v1.0',
+                    meta: { claims: revokedClaims },
+                    resource: { resourceType: 'Consent', meta: { claims: revokedClaims } },
+                }],
+        },
+    };
+    const consent = await deps.submitAndPoll(deps.individualConsentR4BatchPath(routeCtx), deps.individualConsentR4PollPath(routeCtx), consentPayload, input.pollOptions);
+    return {
+        thid,
+        consent,
+        consentClaims: revokedClaims,
+    };
+}
 export async function generateDigitalTwinFromSubjectDataWithDeps(routeCtx, input, deps) {
     const payload = {
         thid: input.compositionPayload.thid || `digital-twin-${createRuntimeUuid()}`,
@@ -384,9 +428,10 @@ function buildEmployeeLifecyclePayload(input) {
     };
 }
 function buildIndividualOrganizationLifecyclePayload(input) {
-    const claims = input.organizationClaims || {};
-    const payload = new IndividualOrganizationLifecycleDraft()
-        .setClaims(claims)
+    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) {