gdc-sdk-front-ts 2.1.0 → 2.2.1

package/README.md

@@ -7,8 +7,11 @@ profile/session runtime logic, or orchestration tests.
 Short rule:
 
 - `101` tests must stay didactic and step by step
-- reusable fixtures/types must come from `gdc-common-utils-ts` instead of
-  being repeated as frontend-local literals
+- `gdc-common-utils-ts` owns the canonical step-by-step editors/readers,
+  shared fixtures, and reusable payload examples
+- `gdc-sdk-front-ts` starts at `ProfileRuntime -> loadProfile(...) ->
+  workspace/session -> actor facade` and only then handles frontend runtime
+  orchestration
 
 Frontend runtime package for consuming the shared GDC SDK contracts in web or
 mobile apps.
@@ -39,7 +42,8 @@ If you are integrating this package for the first time, open these in order:
    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(...)`,
+  Real frontend/native setup, injected runtime adapters, `loadProfile(...)`
+  into one loaded workspace/session, `new ClientSDK(...)`,
   `initializeCommunicationIdentity(...)`, `initializeSession(...)`, and the
   public actor entrypoints exposed by `ProfileManager.asXxx()`.
 2. [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)
@@ -72,6 +76,8 @@ If you need the shortest path:
   [`ClientSDK`](src/ClientSDK.ts)
 - profile/session bootstrap:
   [`initializeSession(...)`](./docs/101-SDK_INTEGRATION.md)
+- loaded profile workspace bootstrap:
+  `new ProfileRuntime(...).loadProfile(...)`
 - first public actor entrypoints:
   `session.asHostOnboarding()`, `session.asOrganizationController()`,
   `session.asIndividualController()`, `session.asProfessional()`

package/dist/ClientSDK.d.ts

@@ -1,7 +1,7 @@
 import { ProfileManager } from './ProfileManager.js';
 import { ProfileRegistry } from './ProfileRegistry.js';
 import type { AppInfo, InitializeSessionParams, IVerifier, IVaultRepository, ProfileRegistryEntry, SdkConfig } from './types.js';
-import { type ResolvedAppInfo } from 'gdc-sdk-core-ts';
+import { type AuthorityResolution, type AuthorityResolutionInput, type AuthorityResolver, type ResolvedAppInfo } from 'gdc-sdk-core-ts';
 /**
  * Frontend-facing SDK entry point for profile/session bootstrapping, lightweight
  * provider discovery, and role-scoped session creation.
@@ -94,6 +94,16 @@ export declare class ClientSDK {
      * Clears the current in-memory session reference.
      */
     shutdownSession(): void;
+    /**
+     * Resolves one technical host/authority descriptor from business tenant
+     * context or one already-known subject/public identifier.
+     *
+     * Convenience rule:
+     * - browser/native callers should not have to handcraft `did:web`
+     * - pass a shared resolver when your app already preloaded one
+     * - without a resolver, the SDK falls back to the shared static/legacy rules
+     */
+    resolveAuthority(input: AuthorityResolutionInput, resolver?: AuthorityResolver): Promise<AuthorityResolution>;
     private resolveBaseUrl;
 }
 export type { InitializeSessionParams, ProfileRegistryEntry, };

package/dist/ClientSDK.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { ProfileManager } from './ProfileManager.js';
 import { ProfileRegistry } from './ProfileRegistry.js';
-import { buildAppHeaders, resolveAppInfo, } from 'gdc-sdk-core-ts';
+import { StaticAuthorityResolver, buildAppHeaders, resolveAppInfo, } from 'gdc-sdk-core-ts';
 /**
  * Frontend-facing SDK entry point for profile/session bootstrapping, lightweight
  * provider discovery, and role-scoped session creation.
@@ -154,6 +154,18 @@ export class ClientSDK {
     shutdownSession() {
         this.currentSession = null;
     }
+    /**
+     * Resolves one technical host/authority descriptor from business tenant
+     * context or one already-known subject/public identifier.
+     *
+     * Convenience rule:
+     * - browser/native callers should not have to handcraft `did:web`
+     * - pass a shared resolver when your app already preloaded one
+     * - without a resolver, the SDK falls back to the shared static/legacy rules
+     */
+    async resolveAuthority(input, resolver = new StaticAuthorityResolver()) {
+        return resolver.resolveAuthority(input);
+    }
     async resolveBaseUrl(source) {
         const raw = String(source || '').trim();
         if (!raw)

package/dist/frontend-profile-workspace.d.ts

@@ -0,0 +1,62 @@
+import type { LoadedActorProfile, ProfileLoadRequest, SubjectIndexCompositionRequest, SubjectIndexConnectionRequest, TrustedDeviceRegistrationRequest } from 'gdc-sdk-core-ts';
+import { ProfileManager } from './ProfileManager.js';
+import type { FrontendProfileRuntimeClient, FrontendSubjectIndexCompositionResult, FrontendSubjectIndexConnectionResult, FrontendTrustedDeviceRegistrationResult } from './frontend-profile-runtime.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 type { FrontRuntimeClient } from './orchestration/client-port.js';
+export type FrontendLoadedActorProfile = LoadedActorProfile & {
+    actorSession: ProfileManager;
+};
+export type LoadedProfile = FrontendLoadedActorProfile;
+/**
+ * Frontend loaded-profile workspace that keeps the login/profile bootstrap
+ * steps explicit and then exposes actor-scoped facades from that loaded
+ * profile.
+ */
+export declare class LoadedProfileWorkspace {
+    readonly profile: FrontendLoadedActorProfile;
+    readonly actorSession: ProfileManager;
+    private readonly profileRuntime;
+    private readonly facadeClient?;
+    constructor(profileRuntime: FrontendProfileRuntimeClient, loadedProfile: LoadedActorProfile, facadeClient?: FrontRuntimeClient);
+    registerTrustedDevice(input: TrustedDeviceRegistrationRequest): Promise<FrontendTrustedDeviceRegistrationResult>;
+    connectToSubjectIndex(input: SubjectIndexConnectionRequest): Promise<FrontendSubjectIndexConnectionResult>;
+    getSubjectIndexComposition(input: SubjectIndexCompositionRequest): Promise<FrontendSubjectIndexCompositionResult>;
+    asHostOnboarding(): HostOnboardingSdk;
+    asOrganizationController(): OrganizationControllerSdk;
+    asOrganizationEmployee(): OrganizationEmployeeSdk;
+    asIndividualController(): IndividualControllerSdk;
+    asIndividualMember(): IndividualMemberSdk;
+    asPersonal(): PersonalSdk;
+    asProfessional(): ProfessionalSdk;
+    private requireFacadeClient;
+}
+/**
+ * Frontend counterpart to the backend loaded-profile runtime:
+ * inject adapters once, load one protected profile, then work from the
+ * returned workspace/session facade instead of one-off helper calls.
+ */
+export declare class ProfileRuntime {
+    private readonly profileRuntime;
+    private readonly facadeClient?;
+    constructor(profileRuntime: FrontendProfileRuntimeClient, facadeClient?: FrontRuntimeClient | undefined);
+    loadProfile(input: ProfileLoadRequest): Promise<LoadedProfileWorkspace>;
+}
+export declare function createLoadedProfileWorkspace(profileRuntime: FrontendProfileRuntimeClient, loadedProfile: LoadedActorProfile, facadeClient?: FrontRuntimeClient): LoadedProfileWorkspace;
+/**
+ * @deprecated Prefer `LoadedProfileWorkspace`.
+ */
+export { LoadedProfileWorkspace as FrontendProfileWorkspace };
+/**
+ * @deprecated Prefer `ProfileRuntime`.
+ */
+export { ProfileRuntime as FrontendProfileWorkspaceRuntime };
+/**
+ * @deprecated Prefer `createLoadedProfileWorkspace`.
+ */
+export { createLoadedProfileWorkspace as createFrontendProfileWorkspace };

package/dist/frontend-profile-workspace.js

@@ -0,0 +1,129 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ActorKinds, } from 'gdc-common-utils-ts/constants/actor-session';
+import { ProfileAppTypes } from 'gdc-common-utils-ts/constants';
+import { ProfileManager } from './ProfileManager.js';
+import { getFrontendSubjectIndexComposition, loadFrontendProfile, connectFrontendToSubjectIndex, registerFrontendTrustedDevice, } from './frontend-profile-runtime.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';
+function toSessionProfile(profile) {
+    const descriptor = profile.descriptor || {};
+    const id = String(descriptor.profileId
+        || descriptor.profileDid
+        || descriptor.subjectDid
+        || descriptor.providerDid
+        || 'frontend-profile').trim();
+    return {
+        id,
+        email: String(descriptor.email || '').trim(),
+        role: String(descriptor.actorRole || '').trim(),
+        providerDid: String(descriptor.providerDid || '').trim(),
+        appType: descriptor.appType || ProfileAppTypes.Family,
+        createdAt: new Date().toISOString(),
+    };
+}
+function requireActorKind(profile, actorKind) {
+    if (!profile.session.actorKinds.includes(actorKind)) {
+        throw new Error(`Loaded frontend profile does not expose actor kind '${actorKind}'.`);
+    }
+}
+function requirePersonalCapability(profile) {
+    if (profile.session.actorKinds.includes(ActorKinds.IndividualController)
+        || profile.session.actorKinds.includes(ActorKinds.IndividualMember)) {
+        return;
+    }
+    throw new Error('Loaded frontend profile does not expose one personal-capable actor kind.');
+}
+/**
+ * Frontend loaded-profile workspace that keeps the login/profile bootstrap
+ * steps explicit and then exposes actor-scoped facades from that loaded
+ * profile.
+ */
+export class LoadedProfileWorkspace {
+    constructor(profileRuntime, loadedProfile, facadeClient) {
+        this.profileRuntime = profileRuntime;
+        this.facadeClient = facadeClient;
+        this.actorSession = new ProfileManager(toSessionProfile(loadedProfile), String(loadedProfile.descriptor.providerDid || ''));
+        this.profile = {
+            ...loadedProfile,
+            actorSession: this.actorSession,
+        };
+    }
+    registerTrustedDevice(input) {
+        return registerFrontendTrustedDevice(this.profileRuntime, input);
+    }
+    connectToSubjectIndex(input) {
+        return connectFrontendToSubjectIndex(this.profileRuntime, input);
+    }
+    getSubjectIndexComposition(input) {
+        return getFrontendSubjectIndexComposition(this.profileRuntime, input);
+    }
+    asHostOnboarding() {
+        requireActorKind(this.profile, ActorKinds.HostOnboarding);
+        return new HostOnboardingSdk(this.requireFacadeClient('HostOnboardingSdk'));
+    }
+    asOrganizationController() {
+        requireActorKind(this.profile, ActorKinds.OrganizationController);
+        return new OrganizationControllerSdk(this.requireFacadeClient('OrganizationControllerSdk'));
+    }
+    asOrganizationEmployee() {
+        requireActorKind(this.profile, ActorKinds.OrganizationEmployee);
+        return new OrganizationEmployeeSdk(this.requireFacadeClient('OrganizationEmployeeSdk'));
+    }
+    asIndividualController() {
+        requireActorKind(this.profile, ActorKinds.IndividualController);
+        return new IndividualControllerSdk(this.requireFacadeClient('IndividualControllerSdk'));
+    }
+    asIndividualMember() {
+        requireActorKind(this.profile, ActorKinds.IndividualMember);
+        return new IndividualMemberSdk(this.requireFacadeClient('IndividualMemberSdk'));
+    }
+    asPersonal() {
+        requirePersonalCapability(this.profile);
+        return new PersonalSdk(this.requireFacadeClient('PersonalSdk'));
+    }
+    asProfessional() {
+        requireActorKind(this.profile, ActorKinds.Professional);
+        return new ProfessionalSdk(this.requireFacadeClient('ProfessionalSdk'));
+    }
+    requireFacadeClient(name) {
+        if (!this.facadeClient) {
+            throw new Error(`${name} requires one FrontRuntimeClient on the loaded frontend profile workspace.`);
+        }
+        return this.facadeClient;
+    }
+}
+/**
+ * Frontend counterpart to the backend loaded-profile runtime:
+ * inject adapters once, load one protected profile, then work from the
+ * returned workspace/session facade instead of one-off helper calls.
+ */
+export class ProfileRuntime {
+    constructor(profileRuntime, facadeClient) {
+        this.profileRuntime = profileRuntime;
+        this.facadeClient = facadeClient;
+    }
+    async loadProfile(input) {
+        const profile = await loadFrontendProfile(this.profileRuntime, input);
+        return new LoadedProfileWorkspace(this.profileRuntime, profile, this.facadeClient);
+    }
+}
+export function createLoadedProfileWorkspace(profileRuntime, loadedProfile, facadeClient) {
+    return new LoadedProfileWorkspace(profileRuntime, loadedProfile, facadeClient);
+}
+/**
+ * @deprecated Prefer `LoadedProfileWorkspace`.
+ */
+export { LoadedProfileWorkspace as FrontendProfileWorkspace };
+/**
+ * @deprecated Prefer `ProfileRuntime`.
+ */
+export { ProfileRuntime as FrontendProfileWorkspaceRuntime };
+/**
+ * @deprecated Prefer `createLoadedProfileWorkspace`.
+ */
+export { createLoadedProfileWorkspace as createFrontendProfileWorkspace };

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export * from './ProfileRegistry.js';
 export * from './UserProfileIndexStore.js';
 export * from './ClientSDK.js';
 export * from './frontend-profile-runtime.js';
+export * from './frontend-profile-workspace.js';
 export * from './individual-controller-frontend-runtime.js';
 export * from './discovery/index.js';
 export * from './orchestration/client-port.js';

package/dist/index.js

@@ -14,6 +14,7 @@ export * from './ProfileRegistry.js';
 export * from './UserProfileIndexStore.js';
 export * from './ClientSDK.js';
 export * from './frontend-profile-runtime.js';
+export * from './frontend-profile-workspace.js';
 export * from './individual-controller-frontend-runtime.js';
 export * from './discovery/index.js';
 export * from './orchestration/client-port.js';

package/dist/individual-controller-frontend-runtime.d.ts

@@ -1,11 +1,17 @@
 import type { SubmitAndPollResult } from 'gdc-sdk-core-ts';
 import type { ProfileLoadRequest } from 'gdc-sdk-core-ts';
-import { type FrontendProfileRuntimeClient } from './frontend-profile-runtime.js';
-import { IndividualControllerSdk } from './orchestration/individual-controller-sdk.js';
+import type { ProfileManager } from './ProfileManager.js';
+import { type LoadedProfileWorkspace } from './frontend-profile-workspace.js';
+import type { FrontendProfileRuntimeClient } from './frontend-profile-runtime.js';
+import type { IndividualControllerSdk } from './orchestration/individual-controller-sdk.js';
 import type { FrontClinicalBundleSearchInput, FrontIndividualOrganizationBootstrapInput, FrontIndividualOrganizationConfirmOrderInput, FrontIndividualOrganizationStartResult, FrontRouteContext, FrontRuntimeClient } from './orchestration/client-port.js';
 import type { LoadedActorProfile } from 'gdc-sdk-core-ts';
 export type FrontendIndividualControllerProfile = {
-    profile: LoadedActorProfile;
+    profile: LoadedActorProfile & {
+        actorSession: ProfileManager;
+    };
+    workspace: LoadedProfileWorkspace;
+    actorSession: ProfileManager;
     sdk: IndividualControllerSdk;
 };
 /**

package/dist/individual-controller-frontend-runtime.js

@@ -1,7 +1,6 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { ActorKinds } from 'gdc-common-utils-ts/constants/actor-session';
-import { loadFrontendProfile, } from './frontend-profile-runtime.js';
-import { IndividualControllerSdk } from './orchestration/individual-controller-sdk.js';
+import { ProfileRuntime, } from './frontend-profile-workspace.js';
 /**
  * First pragmatic frontend use-case wrapper on top of the generic v2 profile
  * runtime.
@@ -20,13 +19,15 @@ export class IndividualControllerFrontendRuntime {
      * actor capability before materializing the facade.
      */
     async loadProfile(input) {
-        const profile = await loadFrontendProfile(this.profileRuntime, input);
-        if (!profile.session.actorKinds.includes(ActorKinds.IndividualController)) {
+        const workspace = await new ProfileRuntime(this.profileRuntime, this.facadeClient).loadProfile(input);
+        if (!workspace.profile.session.actorKinds.includes(ActorKinds.IndividualController)) {
             throw new Error('Loaded frontend profile does not expose actor kind \'individual_controller\'.');
         }
         return {
-            profile,
-            sdk: new IndividualControllerSdk(this.facadeClient),
+            profile: workspace.profile,
+            workspace,
+            actorSession: workspace.actorSession,
+            sdk: workspace.asIndividualController(),
         };
     }
     /**

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

@@ -1,8 +1,9 @@
 import type { DeviceAppType, DeviceUserClass } from 'gdc-common-utils-ts/constants';
 import type { LicenseListSearchState } from 'gdc-common-utils-ts/utils/license-list-search';
 import type { LicenseOfferSearchState, LicenseOrderSearchState } from 'gdc-common-utils-ts/utils/license-commercial-search';
+import type { IndividualOrganizationLifecycleEditor } from 'gdc-common-utils-ts/utils/individual-organization-lifecycle';
 import type { IndividualOnboardingDraftInput, IndividualOnboardingDraftResult } from 'gdc-common-utils-ts/models/individual-onboarding';
-import type { BundleSearchQuery, CommunicationInput, EmployeeSearchValue, HostLifecycleInput, HostRouteContext, HostedTenantLifecycleInput, OrganizationDidBindingInput, LegalOrganizationOrderInput, PollOptions, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
+import type { BundleSearchQuery, CommunicationInput, EmployeeSearchValue, HostLifecycleInput, HostRouteContext, HostedTenantLifecycleInput, OrganizationDidBindingInput, LegalOrganizationOrderInput, PollOptions, SmartTokenRequestContract, SubmitAndPollResult, SubmitPayload } from 'gdc-sdk-core-ts';
 export type FrontRouteContext = {
     providerDid: string;
     idToken: string;
@@ -72,16 +73,7 @@ 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 FrontSmartTokenRequestInput = SmartTokenRequestContract;
 export type FrontSmartTokenExchangeResult = {
     status: 'fetched' | 'failed';
     accessToken?: string;
@@ -106,7 +98,13 @@ export type FrontIndividualOrganizationConfirmOrderInput = {
 };
 export type FrontIndividualOrganizationLifecycleInput = {
     organizationClaims?: Record<string, unknown>;
+    individualEditor?: IndividualOrganizationLifecycleEditor;
+    /**
+     * @deprecated Use `individualEditor`.
+     */
+    organizationEditor?: IndividualOrganizationLifecycleEditor;
     resourceId?: string;
+    dataType?: string;
 };
 export type FrontIndividualMemberLifecycleInput = {
     memberClaims?: Record<string, unknown>;

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

@@ -1,9 +1,34 @@
+import { type ProfessionalEmployeeCredentialInput, type ProfessionalSmartVpPayloadInput } from 'gdc-common-utils-ts';
 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>;
+    /**
+     * Returns the normalized public continuity aliases that would be embedded in
+     * the professional identity VC for SMART/OpenID4VP flows.
+     */
+    getIdentitySameAs(input: ProfessionalEmployeeCredentialInput): string[];
+    /**
+     * Builds the canonical professional identity VC used by the shared SMART VP
+     * helpers.
+     */
+    getIdentityVC(input: ProfessionalEmployeeCredentialInput): Record<string, unknown>;
+    /**
+     * Builds the canonical professional identity VP payload used by the shared
+     * SMART/OpenID4VP helpers.
+     */
+    buildIdentityVpPayload(input: ProfessionalSmartVpPayloadInput): Record<string, unknown>;
+    /**
+     * Builds one unsigned compact VP JWT for the canonical professional
+     * identity payload.
+     */
+    buildUnsignedIdentityVpJwt(input: ProfessionalSmartVpPayloadInput, options?: Readonly<{
+        nowSeconds?: number;
+        ttlSeconds?: number;
+        nonce?: string;
+    }>): string;
     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

@@ -1,4 +1,5 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { buildProfessionalIdentityVpPayload, buildUnsignedProfessionalIdentityVpJwt, getProfessionalIdentitySameAs, getProfessionalIdentityVC, } from 'gdc-common-utils-ts';
 import { requireClientMethod } from './client-port.js';
 export class ProfessionalSdk {
     constructor(client) {
@@ -7,6 +8,34 @@ export class ProfessionalSdk {
     requestSmartToken(input) {
         return requireClientMethod(this.client, 'requestSmartToken')(input);
     }
+    /**
+     * Returns the normalized public continuity aliases that would be embedded in
+     * the professional identity VC for SMART/OpenID4VP flows.
+     */
+    getIdentitySameAs(input) {
+        return getProfessionalIdentitySameAs(input);
+    }
+    /**
+     * Builds the canonical professional identity VC used by the shared SMART VP
+     * helpers.
+     */
+    getIdentityVC(input) {
+        return getProfessionalIdentityVC(input);
+    }
+    /**
+     * Builds the canonical professional identity VP payload used by the shared
+     * SMART/OpenID4VP helpers.
+     */
+    buildIdentityVpPayload(input) {
+        return buildProfessionalIdentityVpPayload(input);
+    }
+    /**
+     * Builds one unsigned compact VP JWT for the canonical professional
+     * identity payload.
+     */
+    buildUnsignedIdentityVpJwt(input, options = {}) {
+        return buildUnsignedProfessionalIdentityVpJwt(input, options);
+    }
     ingestCommunicationAndUpdateIndex(ctx, input) {
         return requireClientMethod(this.client, 'ingestCommunicationAndUpdateIndex')(ctx, input);
     }

package/dist/services.d.ts

@@ -1,7 +1,7 @@
 import type { DeviceAppType, DeviceUserClass } from 'gdc-common-utils-ts/constants';
 import type { IndividualOnboardingDraftInput, IndividualOnboardingDraftResult } from 'gdc-common-utils-ts/models/individual-onboarding';
 import { type HostLifecycleInput, type HostRouteContext, type HostedTenantLifecycleInput, type LegalOrganizationOrderInput, type SubmitAndPollResult } from 'gdc-sdk-core-ts';
-import { type FrontLicenseListSearchInput, type FrontLicenseOfferSearchInput, type FrontLicenseOrderSearchInput, type FrontOrganizationEmployeeSearchInput, type FrontGrantProfessionalAccessResult, type FrontSmartTokenExchangeResult, type FrontSmartTokenRequestInput } from './orchestration/client-port.js';
+import { type FrontLicenseListSearchInput, type FrontLicenseOfferSearchInput, type FrontLicenseOrderSearchInput, type FrontIndividualOrganizationLifecycleInput, type FrontOrganizationEmployeeSearchInput, 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;
@@ -70,14 +70,8 @@ export declare class FamilyAdminService {
         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>;
+    disableIndividual(_providerDid: string, _idToken: string, _input: FrontIndividualOrganizationLifecycleInput): Promise<SubmitAndPollResult>;
+    purgeIndividual(_providerDid: string, _idToken: string, _input: FrontIndividualOrganizationLifecycleInput): Promise<SubmitAndPollResult>;
     disableIndividualMember(_providerDid: string, _idToken: string, _input: {
         memberClaims?: Record<string, unknown>;
         resourceId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-front-ts",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "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": "^2.1.0",
-    "gdc-sdk-core-ts": "^2.1.0"
+    "gdc-common-utils-ts": "^2.2.2",
+    "gdc-sdk-core-ts": "~2.2.1"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",