gdc-sdk-node-ts 2.0.2 → 2.0.4

package/dist/orchestration/professional-sdk.d.ts

@@ -1,7 +1,7 @@
 import { type NodeRuntimeClient, type PollOptions, type SubmitAndPollResult, type SubmitPayload } from './client-port.js';
 import type { RouteContext } from '../individual-onboarding.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
-import type { CommunicationIngestionInput, CommunicationParticipantRuntimeSearchInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult } from '../resource-operations.js';
+import type { CommunicationIngestionInput, CommunicationParticipantRuntimeSearchInput, ClinicalBundleSearchInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult } from '../resource-operations.js';
 /**
  * Professional-oriented facade for runtime actions that belong to the
  * professional actor itself after tenant and employee provisioning have already
@@ -29,6 +29,16 @@ export declare class ProfessionalSdk {
      * `NodeHttpClient({ ctx })` instead of being repeated on every call.
      */
     requestSmartToken(input: SmartTokenRequestInput): Promise<SmartTokenExchangeResult>;
+    /**
+     * Executes one clinical `Bundle/_search` using the professional actor
+     * session and tenant route context.
+     */
+    searchClinicalBundle(ctx: RouteContext, input: ClinicalBundleSearchInput): Promise<SubmitAndPollResult>;
+    /**
+     * Reads the latest IPS-oriented document projection available to the
+     * professional actor for one subject.
+     */
+    getLatestIps(ctx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes'>): Promise<SubmitAndPollResult>;
     /**
      * Ingests a FHIR `Communication` and waits for indexing.
      */

package/dist/orchestration/professional-sdk.js

@@ -31,6 +31,20 @@ export class ProfessionalSdk {
     requestSmartToken(input) {
         return requireClientMethod(this.client, 'requestSmartToken')(input);
     }
+    /**
+     * Executes one clinical `Bundle/_search` using the professional actor
+     * session and tenant route context.
+     */
+    searchClinicalBundle(ctx, input) {
+        return requireClientMethod(this.client, 'searchClinicalBundle')(ctx, input);
+    }
+    /**
+     * Reads the latest IPS-oriented document projection available to the
+     * professional actor for one subject.
+     */
+    getLatestIps(ctx, input) {
+        return requireClientMethod(this.client, 'getLatestIps')(ctx, input);
+    }
     /**
      * Ingests a FHIR `Communication` and waits for indexing.
      */

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

@@ -274,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;
@@ -548,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

@@ -4,7 +4,7 @@ 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';
+import { buildEmployeeBatchEntry, buildEmployeeSearchBundle, ConsentClaims, } from 'gdc-sdk-core-ts';
 export async function createOrganizationEmployeeWithDeps(routeCtx, input, options, deps) {
     const payload = buildEmployeeLifecyclePayload({
         routeCtx,
@@ -358,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()}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -16,6 +16,7 @@
     "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:101:live-full-cycle": "npm run build && RUN_LIVE_101_FULL_CYCLE_E2E=1 node --test tests/101-live-full-cycle-bff-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",
@@ -30,8 +31,8 @@
     "test:e2e:live-gw:clean": "bash ./scripts/run-live-gw-clean.sh"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "^2.0.4",
-    "gdc-sdk-core-ts": "^2.0.3"
+    "gdc-common-utils-ts": "^2.0.6",
+    "gdc-sdk-core-ts": "^2.0.4"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",