gdc-sdk-front-ts 0.6.5 → 0.6.6

package/README.md

@@ -14,22 +14,35 @@ Use this package when your frontend needs to:
 This package is frontend-facing. It should explain app flows, not gateway route
 details.
 
+Architectural rule:
+
+- `gdc-sdk-front-ts` should converge on the same actor-scoped facade boundaries
+  as `gdc-sdk-node-ts`
+- transport and adapter details may differ
+- business ownership must not differ by runtime
+
 ## Start Here
 
 If you are integrating this package for the first time, open these in order:
 
-1. [docs/SDK_INTEGRATION_101.md](./docs/SDK_INTEGRATION_101.md)
-   Real frontend/native setup, imports, `new ClientSDK(...)`,
-   `initializeCommunicationIdentity(...)`, provider discovery, and
+1. [gdc-sdk-core-ts/docs/101-SDK_PACKAGE_BOUNDARIES.md](https://github.com/Global-DataCare/gdc-sdk-core-ts/blob/main/docs/101-SDK_PACKAGE_BOUNDARIES.md)
+   Why `core`, `node`, and `front` are separate packages, what each one owns,
+   and why frontend facades should mirror backend actor boundaries.
+1. [docs/101-SDK_INTEGRATION.md](./docs/101-SDK_INTEGRATION.md)
+  Real frontend/native setup, imports, `new ClientSDK(...)`,
+  `initializeCommunicationIdentity(...)`, provider discovery, and
    `initializeSession(...)`.
 2. [docs/DATASPACE_DISCOVERY_FRONTEND_TODO.md](./docs/DATASPACE_DISCOVERY_FRONTEND_TODO.md)
    Frontend discovery guide for BFF-first provider/operator discovery, UI card
    mapping, and copy/paste backend DTO consumption.
-3. [gdc-sdk-core-ts/docs/SDK_FLOWS_101.md](https://github.com/Global-DataCare/gdc-sdk-core-ts/blob/main/docs/SDK_FLOWS_101.md)
+3. [gdc-sdk-core-ts/docs/101-SDK_FLOWS.md](https://github.com/Global-DataCare/gdc-sdk-core-ts/blob/main/docs/101-SDK_FLOWS.md)
    Shared business-flow map by actor family.
-4. [gdc-common-utils-ts/src/examples/frontend-session.ts](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/src/examples/frontend-session.ts)
+4. [gdc-sdk-node-ts/docs/101-LIVE_GW_LOCAL.md](https://github.com/Global-DataCare/gdc-sdk-node-ts/blob/main/docs/101-LIVE_GW_LOCAL.md)
+   Canonical local/TTY/Docker GW reference when the frontend team also needs a
+   real local GW running for end-to-end checks.
+5. [gdc-common-utils-ts/src/examples/frontend-session.ts](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/src/examples/frontend-session.ts)
    Shared profile/session payload source of truth.
-5. [gdc-common-utils-ts/docs/LIFECYCLE_101.md](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/docs/LIFECYCLE_101.md)
+6. [gdc-common-utils-ts/docs/LIFECYCLE_101.md](https://github.com/Global-DataCare/gdc-common-utils-ts/blob/main/docs/LIFECYCLE_101.md)
    Canonical lifecycle semantics and reusable placeholders for UI and portal flows.
 
 If you need the shortest path:
@@ -37,12 +50,12 @@ If you need the shortest path:
 - app identity required by GW CORE:
   `appId` mandatory, `appVersion` optional with default `v1.0`
 - frontend technical identity:
-  [`initializeCommunicationIdentity(...)`](./docs/SDK_INTEGRATION_101.md)
+  [`initializeCommunicationIdentity(...)`](./docs/101-SDK_INTEGRATION.md)
   for the technical device/channel profile identity, not the legal organization id
 - main runtime class:
   [`ClientSDK`](src/ClientSDK.ts)
 - profile/session bootstrap:
-  [`initializeSession(...)`](./docs/SDK_INTEGRATION_101.md)
+  [`initializeSession(...)`](./docs/101-SDK_INTEGRATION.md)
 
 ## Executable Usage Examples
 

package/dist/ProfileManager.d.ts

@@ -1,11 +1,25 @@
 import type { DeviceAppType, DeviceUserClass } from 'gdc-common-utils-ts/constants';
 import type { Profile } from './types.js';
 import type { CommonServices, FamilyAdminServices, IndividualServices, OrgAdminServices, ProfessionalServices } from './roleRegistry.js';
+import { HostOnboardingSdk } from './orchestration/host-onboarding-sdk.js';
+import { IndividualControllerSdk } from './orchestration/individual-controller-sdk.js';
+import { IndividualMemberSdk } from './orchestration/individual-member-sdk.js';
+import { OrganizationControllerSdk } from './orchestration/organization-controller-sdk.js';
+import { OrganizationEmployeeSdk } from './orchestration/organization-employee-sdk.js';
+import { PersonalSdk } from './orchestration/personal-sdk.js';
+import { ProfessionalSdk } from './orchestration/professional-sdk.js';
 /**
  * Role-scoped session object returned by `ClientSDK.initializeSession(...)`.
  *
  * It exposes the common/auth surface plus the services allowed by the current
  * profile capabilities.
+ *
+ * Architectural note:
+ * `ProfileManager` remains the frontend session/composition entry point, but it
+ * also materializes actor-scoped facades that mirror `gdc-sdk-node-ts`.
+ *
+ * The goal is to preserve the legacy/frontend-friendly session API while
+ * keeping the same actor boundaries as the backend runtime.
  */
 export declare class ProfileManager {
     readonly profile: Profile;
@@ -17,6 +31,7 @@ export declare class ProfileManager {
     readonly familyAdmin?: FamilyAdminServices;
     readonly individual?: IndividualServices;
     readonly professional?: ProfessionalServices;
+    private readonly runtimeClient;
     /**
      * @param profile Current logical profile.
      * @param orgDid DID of the provider/organization used as the session anchor.
@@ -131,6 +146,13 @@ export declare class ProfileManager {
     }): Promise<{
         thid: string;
     }>;
+    asHostOnboarding(): HostOnboardingSdk;
+    asOrganizationController(): OrganizationControllerSdk;
+    asOrganizationEmployee(): OrganizationEmployeeSdk;
+    asIndividualController(): IndividualControllerSdk;
+    asIndividualMember(): IndividualMemberSdk;
+    asPersonal(): PersonalSdk;
+    asProfessional(): ProfessionalSdk;
 }
 /**
  * Preferred neutral frontend actor-session surface.

package/dist/ProfileManager.js

@@ -1,11 +1,26 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { CommonAuthService } from './services.js';
 import { mapCapabilitiesToServices } from './capabilityMapper.js';
+import { HostOnboardingSdk, } from './orchestration/host-onboarding-sdk.js';
+import { IndividualControllerSdk } from './orchestration/individual-controller-sdk.js';
+import { IndividualMemberSdk } from './orchestration/individual-member-sdk.js';
+import { OrganizationControllerSdk } from './orchestration/organization-controller-sdk.js';
+import { OrganizationEmployeeSdk } from './orchestration/organization-employee-sdk.js';
+import { PersonalSdk } from './orchestration/personal-sdk.js';
+import { ProfessionalSdk } from './orchestration/professional-sdk.js';
+import { createSyntheticSubmitAndPollResult } from './orchestration/client-port.js';
 /**
  * Role-scoped session object returned by `ClientSDK.initializeSession(...)`.
  *
  * It exposes the common/auth surface plus the services allowed by the current
  * profile capabilities.
+ *
+ * Architectural note:
+ * `ProfileManager` remains the frontend session/composition entry point, but it
+ * also materializes actor-scoped facades that mirror `gdc-sdk-node-ts`.
+ *
+ * The goal is to preserve the legacy/frontend-friendly session API while
+ * keeping the same actor boundaries as the backend runtime.
  */
 export class ProfileManager {
     /**
@@ -21,6 +36,111 @@ export class ProfileManager {
         this.familyAdmin = mapped.familyAdmin;
         this.individual = mapped.individual;
         this.professional = mapped.professional;
+        this.runtimeClient = {
+            activateOrganizationInGatewayFromIcaProof: (input) => {
+                if (!this.orgAdmin?.admin)
+                    throw new Error('orgAdmin.admin service is not available for this profile.');
+                return this.orgAdmin.admin.activateOrganizationInGatewayFromIcaProof(input);
+            },
+            confirmLegalOrganizationOrder: (input) => {
+                if (!this.orgAdmin?.admin)
+                    throw new Error('orgAdmin.admin service is not available for this profile.');
+                return this.orgAdmin.admin.confirmLegalOrganizationOrder(input);
+            },
+            createOrganizationEmployee: (ctx, input) => {
+                if (!this.orgAdmin?.admin)
+                    throw new Error('orgAdmin.admin service is not available for this profile.');
+                return this.orgAdmin.admin.createOrganizationEmployee(ctx.providerDid, ctx.idToken, input)
+                    .then((result) => createSyntheticSubmitAndPollResult(result.thid));
+            },
+            disableEmployee: (ctx, input) => {
+                if (!this.orgAdmin?.admin)
+                    throw new Error('orgAdmin.admin service is not available for this profile.');
+                return this.orgAdmin.admin.disableEmployee(ctx.providerDid, ctx.idToken, input);
+            },
+            purgeEmployee: (ctx, input) => {
+                if (!this.orgAdmin?.admin)
+                    throw new Error('orgAdmin.admin service is not available for this profile.');
+                return this.orgAdmin.admin.purgeEmployee(ctx.providerDid, ctx.idToken, input);
+            },
+            activateEmployeeDeviceWithActivationRequest: (ctx, input) => this.common.auth.activateEmployeeDeviceWithActivationRequest(input.activationCode, ctx.providerDid, ctx.idToken, input.dcrPayload),
+            requestSmartToken: (input) => this.common.auth.requestSmartToken(input),
+            startIndividualOrganization: (ctx, input) => {
+                if (!this.familyAdmin?.admin)
+                    throw new Error('familyAdmin.admin service is not available for this profile.');
+                return this.familyAdmin.admin.startIndividualOrganization(ctx.providerDid, ctx.idToken, input);
+            },
+            confirmIndividualOrganizationOrder: (ctx, input) => {
+                if (!this.familyAdmin?.admin)
+                    throw new Error('familyAdmin.admin service is not available for this profile.');
+                return this.familyAdmin.admin.confirmIndividualOrganizationOrder(ctx.providerDid, ctx.idToken, input);
+            },
+            disableIndividual: (ctx, input) => {
+                if (!this.familyAdmin?.admin)
+                    throw new Error('familyAdmin.admin service is not available for this profile.');
+                return this.familyAdmin.admin.disableIndividual(ctx.providerDid, ctx.idToken, input);
+            },
+            purgeIndividual: (ctx, input) => {
+                if (!this.familyAdmin?.admin)
+                    throw new Error('familyAdmin.admin service is not available for this profile.');
+                return this.familyAdmin.admin.purgeIndividual(ctx.providerDid, ctx.idToken, input);
+            },
+            disableIndividualMember: (ctx, input) => {
+                if (!this.familyAdmin?.admin)
+                    throw new Error('familyAdmin.admin service is not available for this profile.');
+                return this.familyAdmin.admin.disableIndividualMember(ctx.providerDid, ctx.idToken, input);
+            },
+            purgeIndividualMember: (ctx, input) => {
+                if (!this.familyAdmin?.admin)
+                    throw new Error('familyAdmin.admin service is not available for this profile.');
+                return this.familyAdmin.admin.purgeIndividualMember(ctx.providerDid, ctx.idToken, input);
+            },
+            grantProfessionalAccess: (ctx, input) => {
+                if (this.professional?.physician) {
+                    return this.professional.physician.grantProfessionalAccess({ ...input, providerDid: ctx.providerDid, requiredScope: ctx.requiredScope, idToken: ctx.idToken });
+                }
+                if (!this.individual?.service)
+                    throw new Error('individual.service is not available for this profile.');
+                return this.individual.service.grantProfessionalAccess({ ...input, providerDid: ctx.providerDid, requiredScope: ctx.requiredScope || '', idToken: ctx.idToken });
+            },
+            importIpsOrFhirAndUpdateIndex: (ctx, input) => {
+                if (!this.individual?.service)
+                    throw new Error('individual.service is not available for this profile.');
+                return this.individual.service.importIpsOrFhirAndUpdateIndex(input.compositionPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.format).then((result) => createSyntheticSubmitAndPollResult(result.thid));
+            },
+            upsertRelatedPersonAndPoll: (ctx, input) => {
+                if (!this.individual?.service)
+                    throw new Error('individual.service is not available for this profile.');
+                return this.individual.service.upsertRelatedPersonAndPoll(input.relatedPersonPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken);
+            },
+            ingestCommunicationAndUpdateIndex: (ctx, input) => {
+                if (this.professional?.physician) {
+                    return this.professional.physician.ingestCommunicationAndUpdateIndex(input.communicationPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
+                }
+                if (this.professional?.paramedic) {
+                    return this.professional.paramedic.ingestCommunicationAndUpdateIndex(input.communicationPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
+                }
+                if (!this.individual?.service)
+                    throw new Error('individual.service is not available for this profile.');
+                return this.individual.service.ingestCommunicationAndUpdateIndex(input.communicationPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.pathFormatSegment);
+            },
+            generateDigitalTwinFromSubjectData: (ctx, input) => {
+                if (!this.individual?.service)
+                    throw new Error('individual.service is not available for this profile.');
+                return this.individual.service.generateDigitalTwinFromSubjectData(input.compositionPayload, ctx.providerDid, ctx.requiredScope || '', ctx.idToken, input.format).then((result) => createSyntheticSubmitAndPollResult(result.thid));
+            },
+            searchClinicalBundle: (ctx, input) => {
+                if (!this.individual?.service)
+                    throw new Error('individual.service is not available for this profile.');
+                return this.individual.service.searchClinicalBundle(input, ctx.providerDid, ctx.requiredScope || '', ctx.idToken);
+            },
+            getLatestIps: (ctx, subject) => {
+                if (!this.individual?.service)
+                    throw new Error('individual.service is not available for this profile.');
+                return this.individual.service.getLatestIps(subject, ctx.providerDid, ctx.requiredScope || '', ctx.idToken);
+            },
+            submitAndPoll: async (_submitPath, _pollPath, payload) => createSyntheticSubmitAndPollResult(String(payload.thid || `front-${Date.now()}`)),
+        };
     }
     /**
      * Organization-admin helper for employee/professional creation.
@@ -67,6 +187,41 @@ export class ProfileManager {
         }
         return this.individual.service.generateDigitalTwinFromSubjectData(params.compositionPayload, params.providerDid, params.requiredScope, params.idToken, params.format);
     }
+    asHostOnboarding() {
+        if (!this.orgAdmin?.admin)
+            throw new Error('HostOnboardingSdk is not available for this profile.');
+        return new HostOnboardingSdk(this.runtimeClient);
+    }
+    asOrganizationController() {
+        if (!this.orgAdmin?.admin)
+            throw new Error('OrganizationControllerSdk is not available for this profile.');
+        return new OrganizationControllerSdk(this.runtimeClient);
+    }
+    asOrganizationEmployee() {
+        return new OrganizationEmployeeSdk(this.runtimeClient);
+    }
+    asIndividualController() {
+        if (!this.familyAdmin?.admin)
+            throw new Error('IndividualControllerSdk is not available for this profile.');
+        return new IndividualControllerSdk(this.runtimeClient);
+    }
+    asIndividualMember() {
+        if (!this.individual?.service)
+            throw new Error('IndividualMemberSdk is not available for this profile.');
+        return new IndividualMemberSdk(this.runtimeClient);
+    }
+    asPersonal() {
+        if (!this.familyAdmin?.admin && !this.individual?.service) {
+            throw new Error('PersonalSdk is not available for this profile.');
+        }
+        return new PersonalSdk(this.runtimeClient);
+    }
+    asProfessional() {
+        if (!this.professional?.physician && !this.professional?.paramedic && !this.individual?.service) {
+            throw new Error('ProfessionalSdk is not available for this profile.');
+        }
+        return new ProfessionalSdk(this.runtimeClient);
+    }
 }
 /**
  * Preferred neutral frontend actor-session surface.

package/dist/index.d.ts

@@ -12,3 +12,11 @@ export * from './ProfileManager.js';
 export * from './ProfileRegistry.js';
 export * from './ClientSDK.js';
 export * from './discovery/index.js';
+export * from './orchestration/client-port.js';
+export * from './orchestration/host-onboarding-sdk.js';
+export * from './orchestration/organization-controller-sdk.js';
+export * from './orchestration/organization-employee-sdk.js';
+export * from './orchestration/individual-controller-sdk.js';
+export * from './orchestration/individual-member-sdk.js';
+export * from './orchestration/personal-sdk.js';
+export * from './orchestration/professional-sdk.js';

package/dist/index.js

@@ -13,3 +13,11 @@ export * from './ProfileManager.js';
 export * from './ProfileRegistry.js';
 export * from './ClientSDK.js';
 export * from './discovery/index.js';
+export * from './orchestration/client-port.js';
+export * from './orchestration/host-onboarding-sdk.js';
+export * from './orchestration/organization-controller-sdk.js';
+export * from './orchestration/organization-employee-sdk.js';
+export * from './orchestration/individual-controller-sdk.js';
+export * from './orchestration/individual-member-sdk.js';
+export * from './orchestration/personal-sdk.js';
+export * from './orchestration/professional-sdk.js';

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

@@ -0,0 +1,161 @@
+import type { DeviceAppType, DeviceUserClass } from 'gdc-common-utils-ts/constants';
+import type { BundleSearchQuery, CommunicationInput, PollOptions, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
+export type FrontRouteContext = {
+    providerDid: string;
+    idToken: string;
+    requiredScope?: string;
+    format?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api';
+};
+/**
+ * Frontend/runtime-neutral contract consumed by actor-scoped facades in
+ * `gdc-sdk-front-ts`.
+ *
+ * Frontend code still needs the same actor boundaries as `gdc-sdk-node-ts`,
+ * even when execution goes through local services, a BFF, or browser/mobile
+ * adapters instead of direct GW calls.
+ */
+export type FrontOrganizationActivationInput = {
+    vpToken: string;
+    controller?: Record<string, unknown>;
+    service?: Record<string, unknown>;
+    additionalClaims?: Record<string, unknown>;
+};
+export type FrontLegalOrganizationOrderInput = {
+    offerId: string;
+    orderClaims?: Record<string, unknown>;
+};
+export type FrontOrganizationEmployeeCreationInput = {
+    email: string;
+    role: string;
+    userClass?: DeviceUserClass;
+    type?: DeviceAppType;
+    employeeClaims?: Record<string, unknown>;
+};
+export type FrontOrganizationEmployeeLifecycleInput = {
+    employeeClaims?: Record<string, unknown>;
+    resourceId?: string;
+};
+export type FrontEmployeeDeviceActivationRequestInput = {
+    activationCode: string;
+    dcrPayload?: Record<string, unknown>;
+};
+export type FrontSmartTokenRequestInput = {
+    idToken: string;
+    scopes: string[];
+    actorDid?: string;
+    subjectDid?: string;
+    clientId?: string;
+    issuer?: string;
+    audience?: string;
+    additionalClaims?: Record<string, unknown>;
+};
+export type FrontSmartTokenExchangeResult = {
+    status: 'fetched' | 'failed';
+    accessToken?: string;
+    tokenType?: string;
+    scopes?: string[];
+    statusCode?: number;
+    response?: unknown;
+};
+export type FrontIndividualOrganizationBootstrapInput = {
+    registrationClaims: object;
+    acceptedOfferId?: string;
+};
+export type FrontIndividualOrganizationStartResult = {
+    registrationThid: string;
+    confirmationThid?: string;
+};
+export type FrontIndividualOrganizationConfirmOrderInput = {
+    offerId: string;
+    orderClaims?: Record<string, unknown>;
+};
+export type FrontIndividualOrganizationLifecycleInput = {
+    organizationClaims?: Record<string, unknown>;
+    resourceId?: string;
+};
+export type FrontIndividualMemberLifecycleInput = {
+    memberClaims?: Record<string, unknown>;
+    resourceId?: string;
+};
+export type FrontIpsOrFhirImportInput = {
+    compositionPayload: object;
+    format?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api';
+};
+export type FrontRelatedPersonUpsertInput = {
+    relatedPersonPayload: object;
+};
+export type FrontCommunicationIngestionInput = {
+    communicationPayload: CommunicationInput & Record<string, unknown>;
+    pathFormatSegment?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api';
+};
+export type FrontClinicalBundleSearchInput = BundleSearchQuery & {
+    requestThid?: string;
+};
+export type FrontGrantProfessionalAccessInput = {
+    subjectDid?: string;
+    subjectPhone?: string;
+    subjectGivenName?: string;
+    actorId?: string | string[] | {
+        didWeb?: string;
+        organizationUrl?: string;
+        organizationTaxId?: string;
+        email?: string;
+        phone?: string;
+    };
+    actor?: string | string[] | {
+        didWeb?: string;
+        organizationUrl?: string;
+        organizationTaxId?: string;
+        email?: string;
+        phone?: string;
+    };
+    actorRole: string;
+    purpose: string;
+    actions: string[];
+    consentIdentifier?: string;
+    consentDate?: string;
+    decision?: 'permit' | 'deny';
+    attachmentContentType?: string;
+    attachmentBase64?: string;
+};
+export type FrontGrantProfessionalAccessResult = {
+    thid: string;
+    consent: SubmitAndPollResult;
+    subjectIdentifier: string;
+    actorIdentifier: string;
+    consentClaims: Record<string, unknown>;
+    claimsCid?: string;
+};
+export type FrontDigitalTwinGenerationInput = {
+    compositionPayload: object;
+    format?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api';
+};
+export type FrontRuntimeClient = {
+    activateOrganizationInGatewayFromIcaProof?: (input: FrontOrganizationActivationInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    confirmLegalOrganizationOrder?: (input: FrontLegalOrganizationOrderInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    createOrganizationEmployee?: (ctx: FrontRouteContext, input: FrontOrganizationEmployeeCreationInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    disableEmployee?: (ctx: FrontRouteContext, input: FrontOrganizationEmployeeLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    purgeEmployee?: (ctx: FrontRouteContext, input: FrontOrganizationEmployeeLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    activateEmployeeDeviceWithActivationRequest?: (ctx: FrontRouteContext, input: FrontEmployeeDeviceActivationRequestInput) => Promise<SubmitAndPollResult>;
+    requestSmartToken?: (input: FrontSmartTokenRequestInput) => Promise<FrontSmartTokenExchangeResult>;
+    startIndividualOrganization?: (ctx: FrontRouteContext, input: FrontIndividualOrganizationBootstrapInput) => Promise<FrontIndividualOrganizationStartResult>;
+    confirmIndividualOrganizationOrder?: (ctx: FrontRouteContext, input: FrontIndividualOrganizationConfirmOrderInput) => Promise<SubmitAndPollResult>;
+    disableIndividual?: (ctx: FrontRouteContext, input: FrontIndividualOrganizationLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    purgeIndividual?: (ctx: FrontRouteContext, input: FrontIndividualOrganizationLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    disableIndividualMember?: (ctx: FrontRouteContext, input: FrontIndividualMemberLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    purgeIndividualMember?: (ctx: FrontRouteContext, input: FrontIndividualMemberLifecycleInput, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+    grantProfessionalAccess?: (ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput) => Promise<FrontGrantProfessionalAccessResult>;
+    importIpsOrFhirAndUpdateIndex?: (ctx: FrontRouteContext, input: FrontIpsOrFhirImportInput) => Promise<SubmitAndPollResult>;
+    upsertRelatedPersonAndPoll?: (ctx: FrontRouteContext, input: FrontRelatedPersonUpsertInput) => Promise<SubmitAndPollResult>;
+    ingestCommunicationAndUpdateIndex?: (ctx: FrontRouteContext, input: FrontCommunicationIngestionInput) => Promise<SubmitAndPollResult>;
+    generateDigitalTwinFromSubjectData?: (ctx: FrontRouteContext, input: FrontDigitalTwinGenerationInput) => Promise<SubmitAndPollResult>;
+    searchClinicalBundle?: (ctx: FrontRouteContext, input: FrontClinicalBundleSearchInput) => Promise<{
+        thid: string;
+    }>;
+    getLatestIps?: (ctx: FrontRouteContext, subject: string) => Promise<{
+        thid: string;
+    }>;
+    submitAndPoll?: (submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+};
+export declare function requireClientMethod<T extends keyof FrontRuntimeClient>(client: FrontRuntimeClient, method: T): NonNullable<FrontRuntimeClient[T]>;
+export declare function createSyntheticSubmitAndPollResult(thid: string, body?: unknown): SubmitAndPollResult;

package/dist/orchestration/client-port.js

@@ -0,0 +1,26 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+export function requireClientMethod(client, method) {
+    const candidate = client[method];
+    if (typeof candidate !== 'function') {
+        throw new Error(`FrontRuntimeClient does not implement '${String(method)}'.`);
+    }
+    return candidate.bind(client);
+}
+export function createSyntheticSubmitAndPollResult(thid, body = { thid, accepted: true }) {
+    return {
+        submit: {
+            status: 202,
+            location: `/jobs/${thid}`,
+            body,
+        },
+        poll: {
+            status: 200,
+            body: {
+                completed: true,
+                thid,
+                ...(body && typeof body === 'object' ? body : { body }),
+            },
+            attempts: 1,
+        },
+    };
+}

package/dist/orchestration/facades.d.ts

@@ -0,0 +1,65 @@
+import type { PollOptions, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
+import { type FrontRuntimeClient, type FrontCommunicationIngestionInput, type FrontDigitalTwinGenerationInput, type FrontEmployeeDeviceActivationRequestInput, type FrontGrantProfessionalAccessInput, type FrontGrantProfessionalAccessResult, type FrontIndividualMemberLifecycleInput, type FrontIndividualOrganizationBootstrapInput, type FrontIndividualOrganizationConfirmOrderInput, type FrontIndividualOrganizationLifecycleInput, type FrontIndividualOrganizationStartResult, type FrontIpsOrFhirImportInput, type FrontLegalOrganizationOrderInput, type FrontOrganizationActivationInput, type FrontOrganizationEmployeeCreationInput, type FrontOrganizationEmployeeLifecycleInput, type FrontRelatedPersonUpsertInput, type FrontRouteContext, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+export declare class HostOnboardingSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    activateOrganizationInGatewayFromIcaProof(input: FrontOrganizationActivationInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    confirmLegalOrganizationOrder(input: FrontLegalOrganizationOrderInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+}
+export declare class OrganizationControllerSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    createOrganizationEmployee(ctx: FrontRouteContext, input: FrontOrganizationEmployeeCreationInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    disableEmployee(ctx: FrontRouteContext, input: FrontOrganizationEmployeeLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    purgeEmployee(ctx: FrontRouteContext, input: FrontOrganizationEmployeeLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    activateEmployeeDeviceWithActivationRequest(ctx: FrontRouteContext, input: FrontEmployeeDeviceActivationRequestInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}
+export declare class OrganizationEmployeeSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    activateEmployeeDeviceWithActivationRequest(ctx: FrontRouteContext, input: FrontEmployeeDeviceActivationRequestInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}
+export declare class IndividualControllerSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    startIndividualOrganization(ctx: FrontRouteContext, input: FrontIndividualOrganizationBootstrapInput): Promise<FrontIndividualOrganizationStartResult>;
+    confirmIndividualOrganizationOrder(ctx: FrontRouteContext, input: FrontIndividualOrganizationConfirmOrderInput): Promise<SubmitAndPollResult>;
+    disableIndividual(ctx: FrontRouteContext, input: FrontIndividualOrganizationLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    purgeIndividual(ctx: FrontRouteContext, input: FrontIndividualOrganizationLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    disableIndividualMember(ctx: FrontRouteContext, input: FrontIndividualMemberLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    purgeIndividualMember(ctx: FrontRouteContext, input: FrontIndividualMemberLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    grantProfessionalAccess(ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput): Promise<FrontGrantProfessionalAccessResult>;
+    importIpsOrFhirAndUpdateIndex(ctx: FrontRouteContext, input: FrontIpsOrFhirImportInput): Promise<SubmitAndPollResult>;
+    upsertRelatedPersonAndPoll(ctx: FrontRouteContext, input: FrontRelatedPersonUpsertInput): Promise<SubmitAndPollResult>;
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    generateDigitalTwinFromSubjectData(ctx: FrontRouteContext, input: FrontDigitalTwinGenerationInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}
+export declare class IndividualMemberSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    upsertRelatedPersonAndPoll(ctx: FrontRouteContext, input: FrontRelatedPersonUpsertInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}
+export declare class PersonalSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    startIndividualOrganization(ctx: FrontRouteContext, input: FrontIndividualOrganizationBootstrapInput): Promise<FrontIndividualOrganizationStartResult>;
+    grantProfessionalAccess(ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput): Promise<FrontGrantProfessionalAccessResult>;
+    importIpsOrFhirAndUpdateIndex(ctx: FrontRouteContext, input: FrontIpsOrFhirImportInput): Promise<SubmitAndPollResult>;
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    generateDigitalTwinFromSubjectData(ctx: FrontRouteContext, input: FrontDigitalTwinGenerationInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+    submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+}
+export declare class ProfessionalSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    grantProfessionalAccess(ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput): Promise<FrontGrantProfessionalAccessResult>;
+    submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+}

package/dist/orchestration/facades.js

@@ -0,0 +1,142 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class HostOnboardingSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    activateOrganizationInGatewayFromIcaProof(input, pollOptions) {
+        return requireClientMethod(this.client, 'activateOrganizationInGatewayFromIcaProof')(input, pollOptions);
+    }
+    confirmLegalOrganizationOrder(input, pollOptions) {
+        return requireClientMethod(this.client, 'confirmLegalOrganizationOrder')(input, pollOptions);
+    }
+    submitAndPoll(submitPath, pollPath, payload, pollOptions) {
+        return requireClientMethod(this.client, 'submitAndPoll')(submitPath, pollPath, payload, pollOptions);
+    }
+}
+export class OrganizationControllerSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    createOrganizationEmployee(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'createOrganizationEmployee')(ctx, input, pollOptions);
+    }
+    disableEmployee(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'disableEmployee')(ctx, input, pollOptions);
+    }
+    purgeEmployee(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'purgeEmployee')(ctx, input, pollOptions);
+    }
+    activateEmployeeDeviceWithActivationRequest(ctx, input) {
+        return requireClientMethod(this.client, 'activateEmployeeDeviceWithActivationRequest')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}
+export class OrganizationEmployeeSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    activateEmployeeDeviceWithActivationRequest(ctx, input) {
+        return requireClientMethod(this.client, 'activateEmployeeDeviceWithActivationRequest')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}
+export class IndividualControllerSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    startIndividualOrganization(ctx, input) {
+        return requireClientMethod(this.client, 'startIndividualOrganization')(ctx, input);
+    }
+    confirmIndividualOrganizationOrder(ctx, input) {
+        return requireClientMethod(this.client, 'confirmIndividualOrganizationOrder')(ctx, input);
+    }
+    disableIndividual(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'disableIndividual')(ctx, input, pollOptions);
+    }
+    purgeIndividual(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'purgeIndividual')(ctx, input, pollOptions);
+    }
+    disableIndividualMember(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'disableIndividualMember')(ctx, input, pollOptions);
+    }
+    purgeIndividualMember(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'purgeIndividualMember')(ctx, input, pollOptions);
+    }
+    grantProfessionalAccess(ctx, input) {
+        return requireClientMethod(this.client, 'grantProfessionalAccess')(ctx, input);
+    }
+    importIpsOrFhirAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'importIpsOrFhirAndUpdateIndex')(ctx, input);
+    }
+    upsertRelatedPersonAndPoll(ctx, input) {
+        return requireClientMethod(this.client, 'upsertRelatedPersonAndPoll')(ctx, input);
+    }
+    ingestCommunicationAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
+    }
+    generateDigitalTwinFromSubjectData(ctx, input) {
+        return requireClientMethod(this.client, 'generateDigitalTwinFromSubjectData')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}
+export class IndividualMemberSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    upsertRelatedPersonAndPoll(ctx, input) {
+        return requireClientMethod(this.client, 'upsertRelatedPersonAndPoll')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}
+export class PersonalSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    startIndividualOrganization(ctx, input) {
+        return requireClientMethod(this.client, 'startIndividualOrganization')(ctx, input);
+    }
+    grantProfessionalAccess(ctx, input) {
+        return requireClientMethod(this.client, 'grantProfessionalAccess')(ctx, input);
+    }
+    importIpsOrFhirAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'importIpsOrFhirAndUpdateIndex')(ctx, input);
+    }
+    ingestCommunicationAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
+    }
+    generateDigitalTwinFromSubjectData(ctx, input) {
+        return requireClientMethod(this.client, 'generateDigitalTwinFromSubjectData')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+    submitAndPoll(submitPath, pollPath, payload, pollOptions) {
+        return requireClientMethod(this.client, 'submitAndPoll')(submitPath, pollPath, payload, pollOptions);
+    }
+}
+export class ProfessionalSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+    ingestCommunicationAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
+    }
+    grantProfessionalAccess(ctx, input) {
+        return requireClientMethod(this.client, 'grantProfessionalAccess')(ctx, input);
+    }
+    submitAndPoll(submitPath, pollPath, payload, pollOptions) {
+        return requireClientMethod(this.client, 'submitAndPoll')(submitPath, pollPath, payload, pollOptions);
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { PollOptions, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
+import { type FrontLegalOrganizationOrderInput, type FrontOrganizationActivationInput, type FrontRuntimeClient } from './client-port.js';
+export declare class HostOnboardingSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    activateOrganizationInGatewayFromIcaProof(input: FrontOrganizationActivationInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    confirmLegalOrganizationOrder(input: FrontLegalOrganizationOrderInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+}

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

@@ -0,0 +1,16 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class HostOnboardingSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    activateOrganizationInGatewayFromIcaProof(input, pollOptions) {
+        return requireClientMethod(this.client, 'activateOrganizationInGatewayFromIcaProof')(input, pollOptions);
+    }
+    confirmLegalOrganizationOrder(input, pollOptions) {
+        return requireClientMethod(this.client, 'confirmLegalOrganizationOrder')(input, pollOptions);
+    }
+    submitAndPoll(submitPath, pollPath, payload, pollOptions) {
+        return requireClientMethod(this.client, 'submitAndPoll')(submitPath, pollPath, payload, pollOptions);
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { PollOptions, SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import { type FrontCommunicationIngestionInput, type FrontDigitalTwinGenerationInput, type FrontGrantProfessionalAccessInput, type FrontGrantProfessionalAccessResult, type FrontIndividualMemberLifecycleInput, type FrontIndividualOrganizationBootstrapInput, type FrontIndividualOrganizationConfirmOrderInput, type FrontIndividualOrganizationLifecycleInput, type FrontIndividualOrganizationStartResult, type FrontIpsOrFhirImportInput, type FrontRelatedPersonUpsertInput, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+export declare class IndividualControllerSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    startIndividualOrganization(ctx: FrontRouteContext, input: FrontIndividualOrganizationBootstrapInput): Promise<FrontIndividualOrganizationStartResult>;
+    confirmIndividualOrganizationOrder(ctx: FrontRouteContext, input: FrontIndividualOrganizationConfirmOrderInput): Promise<SubmitAndPollResult>;
+    disableIndividual(ctx: FrontRouteContext, input: FrontIndividualOrganizationLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    purgeIndividual(ctx: FrontRouteContext, input: FrontIndividualOrganizationLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    disableIndividualMember(ctx: FrontRouteContext, input: FrontIndividualMemberLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    purgeIndividualMember(ctx: FrontRouteContext, input: FrontIndividualMemberLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    grantProfessionalAccess(ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput): Promise<FrontGrantProfessionalAccessResult>;
+    importIpsOrFhirAndUpdateIndex(ctx: FrontRouteContext, input: FrontIpsOrFhirImportInput): Promise<SubmitAndPollResult>;
+    upsertRelatedPersonAndPoll(ctx: FrontRouteContext, input: FrontRelatedPersonUpsertInput): Promise<SubmitAndPollResult>;
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    generateDigitalTwinFromSubjectData(ctx: FrontRouteContext, input: FrontDigitalTwinGenerationInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}

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

@@ -0,0 +1,43 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class IndividualControllerSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    startIndividualOrganization(ctx, input) {
+        return requireClientMethod(this.client, 'startIndividualOrganization')(ctx, input);
+    }
+    confirmIndividualOrganizationOrder(ctx, input) {
+        return requireClientMethod(this.client, 'confirmIndividualOrganizationOrder')(ctx, input);
+    }
+    disableIndividual(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'disableIndividual')(ctx, input, pollOptions);
+    }
+    purgeIndividual(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'purgeIndividual')(ctx, input, pollOptions);
+    }
+    disableIndividualMember(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'disableIndividualMember')(ctx, input, pollOptions);
+    }
+    purgeIndividualMember(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'purgeIndividualMember')(ctx, input, pollOptions);
+    }
+    grantProfessionalAccess(ctx, input) {
+        return requireClientMethod(this.client, 'grantProfessionalAccess')(ctx, input);
+    }
+    importIpsOrFhirAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'importIpsOrFhirAndUpdateIndex')(ctx, input);
+    }
+    upsertRelatedPersonAndPoll(ctx, input) {
+        return requireClientMethod(this.client, 'upsertRelatedPersonAndPoll')(ctx, input);
+    }
+    ingestCommunicationAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
+    }
+    generateDigitalTwinFromSubjectData(ctx, input) {
+        return requireClientMethod(this.client, 'generateDigitalTwinFromSubjectData')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import { type FrontRelatedPersonUpsertInput, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+export declare class IndividualMemberSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    upsertRelatedPersonAndPoll(ctx: FrontRouteContext, input: FrontRelatedPersonUpsertInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}

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

@@ -0,0 +1,13 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class IndividualMemberSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    upsertRelatedPersonAndPoll(ctx, input) {
+        return requireClientMethod(this.client, 'upsertRelatedPersonAndPoll')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { PollOptions, SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import { type FrontEmployeeDeviceActivationRequestInput, type FrontOrganizationEmployeeCreationInput, type FrontOrganizationEmployeeLifecycleInput, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+export declare class OrganizationControllerSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    createOrganizationEmployee(ctx: FrontRouteContext, input: FrontOrganizationEmployeeCreationInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    disableEmployee(ctx: FrontRouteContext, input: FrontOrganizationEmployeeLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    purgeEmployee(ctx: FrontRouteContext, input: FrontOrganizationEmployeeLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+    activateEmployeeDeviceWithActivationRequest(ctx: FrontRouteContext, input: FrontEmployeeDeviceActivationRequestInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}

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

@@ -0,0 +1,22 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class OrganizationControllerSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    createOrganizationEmployee(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'createOrganizationEmployee')(ctx, input, pollOptions);
+    }
+    disableEmployee(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'disableEmployee')(ctx, input, pollOptions);
+    }
+    purgeEmployee(ctx, input, pollOptions) {
+        return requireClientMethod(this.client, 'purgeEmployee')(ctx, input, pollOptions);
+    }
+    activateEmployeeDeviceWithActivationRequest(ctx, input) {
+        return requireClientMethod(this.client, 'activateEmployeeDeviceWithActivationRequest')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}

package/dist/orchestration/organization-employee-sdk.d.ts

@@ -0,0 +1,8 @@
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import { type FrontEmployeeDeviceActivationRequestInput, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+export declare class OrganizationEmployeeSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    activateEmployeeDeviceWithActivationRequest(ctx: FrontRouteContext, input: FrontEmployeeDeviceActivationRequestInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+}

package/dist/orchestration/organization-employee-sdk.js

@@ -0,0 +1,13 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class OrganizationEmployeeSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    activateEmployeeDeviceWithActivationRequest(ctx, input) {
+        return requireClientMethod(this.client, 'activateEmployeeDeviceWithActivationRequest')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { PollOptions, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
+import { type FrontCommunicationIngestionInput, type FrontDigitalTwinGenerationInput, type FrontGrantProfessionalAccessInput, type FrontGrantProfessionalAccessResult, type FrontIndividualOrganizationBootstrapInput, type FrontIndividualOrganizationStartResult, type FrontIpsOrFhirImportInput, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+export declare class PersonalSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    startIndividualOrganization(ctx: FrontRouteContext, input: FrontIndividualOrganizationBootstrapInput): Promise<FrontIndividualOrganizationStartResult>;
+    grantProfessionalAccess(ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput): Promise<FrontGrantProfessionalAccessResult>;
+    importIpsOrFhirAndUpdateIndex(ctx: FrontRouteContext, input: FrontIpsOrFhirImportInput): Promise<SubmitAndPollResult>;
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    generateDigitalTwinFromSubjectData(ctx: FrontRouteContext, input: FrontDigitalTwinGenerationInput): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+    submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+}

package/dist/orchestration/personal-sdk.js

@@ -0,0 +1,28 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class PersonalSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    startIndividualOrganization(ctx, input) {
+        return requireClientMethod(this.client, 'startIndividualOrganization')(ctx, input);
+    }
+    grantProfessionalAccess(ctx, input) {
+        return requireClientMethod(this.client, 'grantProfessionalAccess')(ctx, input);
+    }
+    importIpsOrFhirAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'importIpsOrFhirAndUpdateIndex')(ctx, input);
+    }
+    ingestCommunicationAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
+    }
+    generateDigitalTwinFromSubjectData(ctx, input) {
+        return requireClientMethod(this.client, 'generateDigitalTwinFromSubjectData')(ctx, input);
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+    submitAndPoll(submitPath, pollPath, payload, pollOptions) {
+        return requireClientMethod(this.client, 'submitAndPoll')(submitPath, pollPath, payload, pollOptions);
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { PollOptions, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
+import { type FrontCommunicationIngestionInput, type FrontGrantProfessionalAccessInput, type FrontGrantProfessionalAccessResult, type FrontRouteContext, type FrontRuntimeClient, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './client-port.js';
+export declare class ProfessionalSdk {
+    private readonly client;
+    constructor(client: FrontRuntimeClient);
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+    ingestCommunicationAndUpdateIndex(ctx: FrontRouteContext, input: FrontCommunicationIngestionInput): Promise<SubmitAndPollResult>;
+    grantProfessionalAccess(ctx: FrontRouteContext, input: FrontGrantProfessionalAccessInput): Promise<FrontGrantProfessionalAccessResult>;
+    submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
+}

package/dist/orchestration/professional-sdk.js

@@ -0,0 +1,19 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { requireClientMethod } from './client-port.js';
+export class ProfessionalSdk {
+    constructor(client) {
+        this.client = client;
+    }
+    requestSmartToken(input) {
+        return requireClientMethod(this.client, 'requestSmartToken')(input);
+    }
+    ingestCommunicationAndUpdateIndex(ctx, input) {
+        return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
+    }
+    grantProfessionalAccess(ctx, input) {
+        return requireClientMethod(this.client, 'grantProfessionalAccess')(ctx, input);
+    }
+    submitAndPoll(submitPath, pollPath, payload, pollOptions) {
+        return requireClientMethod(this.client, 'submitAndPoll')(submitPath, pollPath, payload, pollOptions);
+    }
+}

package/dist/services.d.ts

@@ -1,10 +1,24 @@
 import type { DeviceAppType, DeviceUserClass } from 'gdc-common-utils-ts/constants';
+import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
+import { type FrontGrantProfessionalAccessResult, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './orchestration/client-port.js';
 export declare class CommonAuthService {
     activateDevice(_licenseCode: string, _providerDid: string, _idToken: string): Promise<{
         thid: string;
     }>;
+    activateEmployeeDeviceWithActivationRequest(_activationCode: string, _providerDid: string, _idToken: string, _dcrPayload?: Record<string, unknown>): Promise<SubmitAndPollResult>;
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
 }
 export declare class OrgAdminService {
+    activateOrganizationInGatewayFromIcaProof(_input: {
+        vpToken: string;
+        controller?: Record<string, unknown>;
+        service?: Record<string, unknown>;
+        additionalClaims?: Record<string, unknown>;
+    }): Promise<SubmitAndPollResult>;
+    confirmLegalOrganizationOrder(_input: {
+        offerId: string;
+        orderClaims?: Record<string, unknown>;
+    }): Promise<SubmitAndPollResult>;
     createOrganizationEmployee(_providerDid: string, _idToken: string, _params: {
         email: string;
         role: string;
@@ -13,9 +27,24 @@ export declare class OrgAdminService {
     }): Promise<{
         thid: string;
     }>;
+    disableEmployee(_providerDid: string, _idToken: string, _input: {
+        employeeClaims?: Record<string, unknown>;
+        resourceId?: string;
+    }): Promise<SubmitAndPollResult>;
+    purgeEmployee(_providerDid: string, _idToken: string, _input: {
+        employeeClaims?: Record<string, unknown>;
+        resourceId?: string;
+    }): Promise<SubmitAndPollResult>;
 }
 export declare class FamilyAdminService {
-    bootstrapSubjectOrganizationIndex(_params: {
+    startIndividualOrganization(_providerDid: string, _idToken: string, _params: {
+        registrationClaims: object;
+        acceptedOfferId?: string;
+    }): Promise<{
+        registrationThid: string;
+        confirmationThid?: string;
+    }>;
+    bootstrapSubjectOrganizationIndex(params: {
         registrationClaims: object;
         providerDid: string;
         idToken: string;
@@ -24,6 +53,26 @@ export declare class FamilyAdminService {
         registrationThid: string;
         confirmationThid?: string;
     }>;
+    confirmIndividualOrganizationOrder(_providerDid: string, _idToken: string, _input: {
+        offerId: string;
+        orderClaims?: Record<string, unknown>;
+    }): Promise<SubmitAndPollResult>;
+    disableIndividual(_providerDid: string, _idToken: string, _input: {
+        organizationClaims?: Record<string, unknown>;
+        resourceId?: string;
+    }): Promise<SubmitAndPollResult>;
+    purgeIndividual(_providerDid: string, _idToken: string, _input: {
+        organizationClaims?: Record<string, unknown>;
+        resourceId?: string;
+    }): Promise<SubmitAndPollResult>;
+    disableIndividualMember(_providerDid: string, _idToken: string, _input: {
+        memberClaims?: Record<string, unknown>;
+        resourceId?: string;
+    }): Promise<SubmitAndPollResult>;
+    purgeIndividualMember(_providerDid: string, _idToken: string, _input: {
+        memberClaims?: Record<string, unknown>;
+        resourceId?: string;
+    }): Promise<SubmitAndPollResult>;
 }
 export declare class IndividualService {
     /**
@@ -92,16 +141,12 @@ export declare class IndividualService {
         decision?: 'permit' | 'deny';
         attachmentContentType?: string;
         attachmentBase64?: string;
-    }): Promise<{
-        thid: string;
-        subjectIdentifier: string;
-        actorIdentifier: string;
-        consentClaims: Record<string, unknown>;
-        claimsCid?: string;
-    }>;
+    }): Promise<FrontGrantProfessionalAccessResult>;
     generateDigitalTwinFromSubjectData(_compositionPayload: object, _providerDid: string, _requiredScope: string, _idToken: string, _format?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api'): Promise<{
         thid: string;
     }>;
+    upsertRelatedPersonAndPoll(_relatedPersonPayload: object, _providerDid: string, _requiredScope: string, _idToken: string): Promise<SubmitAndPollResult>;
+    ingestCommunicationAndUpdateIndex(_communicationPayload: object, _providerDid: string, _requiredScope: string, _idToken: string, _format?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api'): Promise<SubmitAndPollResult>;
     /**
      * Sends a lightweight communication request description.
      *
@@ -161,7 +206,10 @@ export declare class IndividualService {
         thid: string;
     }>;
 }
-export declare class PhysicianService {
-}
 export declare class ParamedicService {
+    requestSmartToken(input: FrontSmartTokenRequestInput): Promise<FrontSmartTokenExchangeResult>;
+    ingestCommunicationAndUpdateIndex(_communicationPayload: object, _providerDid: string, _requiredScope: string, _idToken: string, _format?: 'org.hl7.fhir.r4' | 'org.hl7.fhir.api'): Promise<SubmitAndPollResult>;
+}
+export declare class PhysicianService extends ParamedicService {
+    grantProfessionalAccess(_params: Record<string, unknown>): Promise<FrontGrantProfessionalAccessResult>;
 }

package/dist/services.js

@@ -1,4 +1,5 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { createSyntheticSubmitAndPollResult, } from './orchestration/client-port.js';
 function requireNonEmptyText(value, fieldName) {
     const normalized = String(value ?? '').trim();
     if (!normalized) {
@@ -6,19 +7,70 @@ function requireNonEmptyText(value, fieldName) {
     }
     return normalized;
 }
+function runtimeThid(prefix) {
+    return `${prefix}-${Date.now()}`;
+}
 export class CommonAuthService {
     async activateDevice(_licenseCode, _providerDid, _idToken) {
         return { thid: `thid-${Date.now()}` };
     }
+    async activateEmployeeDeviceWithActivationRequest(_activationCode, _providerDid, _idToken, _dcrPayload) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('employee-device-activation'));
+    }
+    async requestSmartToken(input) {
+        const scopes = [...new Set((input.scopes || []).filter(Boolean))];
+        return {
+            status: 'fetched',
+            accessToken: `front-token-${Date.now()}`,
+            tokenType: 'Bearer',
+            scopes,
+            statusCode: 200,
+            response: {
+                actorDid: input.actorDid,
+                subjectDid: input.subjectDid,
+                scopes,
+            },
+        };
+    }
 }
 export class OrgAdminService {
+    async activateOrganizationInGatewayFromIcaProof(_input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('host-activation'));
+    }
+    async confirmLegalOrganizationOrder(_input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('host-order-confirmation'));
+    }
     async createOrganizationEmployee(_providerDid, _idToken, _params) {
         return { thid: `thid-${Date.now()}` };
     }
+    async disableEmployee(_providerDid, _idToken, _input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('employee-disable'));
+    }
+    async purgeEmployee(_providerDid, _idToken, _input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('employee-purge'));
+    }
 }
 export class FamilyAdminService {
-    async bootstrapSubjectOrganizationIndex(_params) {
-        return { registrationThid: `thid-${Date.now()}` };
+    async startIndividualOrganization(_providerDid, _idToken, _params) {
+        return { registrationThid: runtimeThid('individual-bootstrap') };
+    }
+    async bootstrapSubjectOrganizationIndex(params) {
+        return this.startIndividualOrganization(params.providerDid, params.idToken, params);
+    }
+    async confirmIndividualOrganizationOrder(_providerDid, _idToken, _input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('individual-order-confirmation'));
+    }
+    async disableIndividual(_providerDid, _idToken, _input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('individual-disable'));
+    }
+    async purgeIndividual(_providerDid, _idToken, _input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('individual-purge'));
+    }
+    async disableIndividualMember(_providerDid, _idToken, _input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('individual-member-disable'));
+    }
+    async purgeIndividualMember(_providerDid, _idToken, _input) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('individual-member-purge'));
     }
 }
 export class IndividualService {
@@ -32,8 +84,10 @@ export class IndividualService {
         return { thid: `thid-${Date.now()}` };
     }
     async grantProfessionalAccess(_params) {
+        const thid = runtimeThid('consent');
         return {
-            thid: `thid-${Date.now()}`,
+            thid,
+            consent: createSyntheticSubmitAndPollResult(thid),
             subjectIdentifier: '',
             actorIdentifier: '',
             consentClaims: {},
@@ -42,6 +96,12 @@ export class IndividualService {
     async generateDigitalTwinFromSubjectData(_compositionPayload, _providerDid, _requiredScope, _idToken, _format) {
         return { thid: `thid-${Date.now()}` };
     }
+    async upsertRelatedPersonAndPoll(_relatedPersonPayload, _providerDid, _requiredScope, _idToken) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('related-person-upsert'));
+    }
+    async ingestCommunicationAndUpdateIndex(_communicationPayload, _providerDid, _requiredScope, _idToken, _format) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('communication-ingest'));
+    }
     /**
      * Sends a lightweight communication request description.
      *
@@ -72,7 +132,30 @@ export class IndividualService {
         return { thid: `thid-${Date.now()}` };
     }
 }
-export class PhysicianService {
-}
 export class ParamedicService {
+    async requestSmartToken(input) {
+        return {
+            status: 'fetched',
+            accessToken: `front-token-${Date.now()}`,
+            tokenType: 'Bearer',
+            scopes: [...new Set((input.scopes || []).filter(Boolean))],
+            statusCode: 200,
+            response: { actorDid: input.actorDid },
+        };
+    }
+    async ingestCommunicationAndUpdateIndex(_communicationPayload, _providerDid, _requiredScope, _idToken, _format) {
+        return createSyntheticSubmitAndPollResult(runtimeThid('professional-communication'));
+    }
+}
+export class PhysicianService extends ParamedicService {
+    async grantProfessionalAccess(_params) {
+        const thid = runtimeThid('professional-consent');
+        return {
+            thid,
+            consent: createSyntheticSubmitAndPollResult(thid),
+            subjectIdentifier: '',
+            actorIdentifier: '',
+            consentClaims: {},
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-front-ts",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "Next-generation frontend runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -17,8 +17,8 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.28.4",
-    "gdc-common-utils-ts": "^1.14.10",
-    "gdc-sdk-core-ts": "^0.6.9"
+    "gdc-common-utils-ts": "^1.14.14",
+    "gdc-sdk-core-ts": "^0.6.12"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",