gdc-sdk-node-ts 2.1.1 → 2.1.4

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

@@ -1,7 +1,7 @@
 import type { ControllerBindingInput } from 'gdc-common-utils-ts/models';
 import type { FamilyOrganizationSummary } from 'gdc-common-utils-ts/utils/family-organization-summary';
 import type { LegalOrganizationVerificationTransactionInput } from 'gdc-common-utils-ts/utils/legal-organization-verification-transaction';
-import type { OrganizationDidBindingInput } from 'gdc-sdk-core-ts';
+import type { IndividualOrganizationLifecycleInput, OrganizationDidBindingInput } from 'gdc-sdk-core-ts';
 import type { LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput } from '../resource-operations.js';
 import type { AsyncPollRequest, OrganizationActivationServiceOptions, PollOptions, PollResult, SubmitAndPollResult, SubmitPayload, SubmitResponse } from 'gdc-sdk-core-ts';
 export type { AsyncPollRequest, PollOptions, PollResult, SubmitAndPollResult, SubmitPayload, SubmitResponse, } from 'gdc-sdk-core-ts';
@@ -13,7 +13,7 @@ import type { FamilyOrganizationSearchInput } from '../family-organization-searc
 import type { EnsureFamilyOrganizationRegistrationInput, EnsureFamilyOrganizationRegistrationResult } from '../family-organization-registration.js';
 import type { OrganizationLicenseOrderConfirmInput } from '../organization-license-order.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
-import type { CommunicationIngestionInput, CommunicationParticipantRuntimeSearchInput, ClinicalBundleSearchInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IndividualOrganizationLifecycleInput, IpsOrFhirImportInput, OrganizationEmployeeCreationInput, OrganizationEmployeeLifecycleInput, OrganizationEmployeeSearchInput, RevokeProfessionalAccessInput, RevokeProfessionalAccessResult, RelatedPersonUpsertInput } from '../resource-operations.js';
+import type { CommunicationIngestionInput, CommunicationParticipantRuntimeSearchInput, ClinicalBundleSearchInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IpsOrFhirImportInput, OrganizationEmployeeCreationInput, OrganizationEmployeeLifecycleInput, OrganizationEmployeeSearchInput, RevokeProfessionalAccessInput, RevokeProfessionalAccessResult, RelatedPersonUpsertInput } from '../resource-operations.js';
 /**
  * Shared node-runtime activation input.
  *

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

@@ -5,7 +5,8 @@ import type { FamilyOrganizationSearchInput } from '../family-organization-searc
 import type { IndividualOrganizationConfirmOrderInput, RouteContext } from '../individual-onboarding.js';
 import type { IndividualOrganizationBootstrapInput, IndividualOrganizationStartResult } from '../individual-start.js';
 import type { NodeCapability } from '../session.js';
-import type { ClinicalBundleSearchInput, CommunicationIngestionInput, CommunicationParticipantRuntimeSearchInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IndividualOrganizationLifecycleInput, IpsOrFhirImportInput, LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput, RevokeProfessionalAccessInput, RevokeProfessionalAccessResult, RelatedPersonUpsertInput } from '../resource-operations.js';
+import type { IndividualOrganizationLifecycleInput } from 'gdc-sdk-core-ts';
+import type { ClinicalBundleSearchInput, CommunicationIngestionInput, CommunicationParticipantRuntimeSearchInput, DigitalTwinGenerationInput, GrantProfessionalAccessInput, GrantProfessionalAccessResult, IndividualMemberLifecycleInput, IpsOrFhirImportInput, LicenseListRuntimeSearchInput, LicenseOfferRuntimeSearchInput, LicenseOrderRuntimeSearchInput, RevokeProfessionalAccessInput, RevokeProfessionalAccessResult, RelatedPersonUpsertInput } from '../resource-operations.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
 /**
  * Individual-controller oriented facade over a `NodeRuntimeClient`.
@@ -55,17 +56,13 @@ export declare class IndividualControllerSdk {
      */
     purgeIndividual(ctx: RouteContext, input: IndividualOrganizationLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /**
-     * Controller-only placeholder for a future individual-member lifecycle flow.
-     *
-     * Current GW CORE still lacks the stable member disable route. The runtime
-     * client currently throws a not-supported error by design.
+     * Soft-disables one individual-member / caregiver relationship through the
+     * current `RelatedPerson/_batch` lifecycle contract.
      */
     disableIndividualMember(ctx: RouteContext, input: IndividualMemberLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /**
-     * Controller-only placeholder for a future individual-member lifecycle flow.
-     *
-     * Current GW CORE still lacks the stable member purge route. The runtime
-     * client currently throws a not-supported error by design.
+     * Purges one previously disabled individual-member / caregiver relationship
+     * through the explicit `RelatedPerson/_purge` lifecycle contract.
      */
     purgeIndividualMember(ctx: RouteContext, input: IndividualMemberLifecycleInput, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /**

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

@@ -73,20 +73,16 @@ export class IndividualControllerSdk {
         return requireClientMethod(this.client, 'purgeIndividual')(ctx, input, pollOptions);
     }
     /**
-     * Controller-only placeholder for a future individual-member lifecycle flow.
-     *
-     * Current GW CORE still lacks the stable member disable route. The runtime
-     * client currently throws a not-supported error by design.
+     * Soft-disables one individual-member / caregiver relationship through the
+     * current `RelatedPerson/_batch` lifecycle contract.
      */
     disableIndividualMember(ctx, input, pollOptions) {
         assertFacadeCapability(this.capabilities, ActorCapabilities.IndividualMemberDisable, ActorKinds.IndividualController, 'disableIndividualMember');
         return requireClientMethod(this.client, 'disableIndividualMember')(ctx, input, pollOptions);
     }
     /**
-     * Controller-only placeholder for a future individual-member lifecycle flow.
-     *
-     * Current GW CORE still lacks the stable member purge route. The runtime
-     * client currently throws a not-supported error by design.
+     * Purges one previously disabled individual-member / caregiver relationship
+     * through the explicit `RelatedPerson/_purge` lifecycle contract.
      */
     purgeIndividualMember(ctx, input, pollOptions) {
         assertFacadeCapability(this.capabilities, ActorCapabilities.IndividualMemberPurge, ActorKinds.IndividualController, 'purgeIndividualMember');

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

@@ -1,3 +1,4 @@
+import { type ProfessionalEmployeeCredentialInput, type ProfessionalSmartVpPayloadInput } from 'gdc-common-utils-ts';
 import { type NodeRuntimeClient, type PollOptions, type SubmitAndPollResult, type SubmitPayload } from './client-port.js';
 import type { RouteContext } from '../individual-onboarding.js';
 import type { SmartTokenExchangeResult, SmartTokenRequestInput } from '../smart-token.js';
@@ -29,6 +30,30 @@ export declare class ProfessionalSdk {
      * `NodeHttpClient({ ctx })` instead of being repeated on every call.
      */
     requestSmartToken(input: SmartTokenRequestInput): Promise<SmartTokenExchangeResult>;
+    /**
+     * 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;
     /**
      * Executes one clinical `Bundle/_search` using the professional actor
      * session and tenant route context.

package/dist/orchestration/professional-sdk.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 // Always create JSDoc, do not use strings inline in keys nor values, use types instead, and reuse the data test examples.
+import { buildProfessionalIdentityVpPayload, buildUnsignedProfessionalIdentityVpJwt, getProfessionalIdentitySameAs, getProfessionalIdentityVC, } from 'gdc-common-utils-ts';
 import { requireClientMethod, submitAndPollWithClient, } from './client-port.js';
 /**
  * Professional-oriented facade for runtime actions that belong to the
@@ -31,6 +32,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);
+    }
     /**
      * Executes one clinical `Bundle/_search` using the professional actor
      * session and tenant route context.

package/dist/resource-operations.d.ts

@@ -1,7 +1,6 @@
-import { IndividualOrganizationLifecycleEditor } from 'gdc-common-utils-ts';
 import type { LicenseOfferSearchState, LicenseOrderSearchState } from 'gdc-common-utils-ts/utils/license-commercial-search';
 import type { LicenseListSearchState } from 'gdc-common-utils-ts/utils/license-list-search';
-import type { BundleSearchQuery, CommunicationInput, DateRange, EmployeeSearchValue } from 'gdc-sdk-core-ts';
+import type { BundleSearchQuery, CommunicationInput, DateRange, EmployeeSearchValue, IndividualOrganizationLifecycleInput } from 'gdc-sdk-core-ts';
 import type { SubmitAndPollResult } from './orchestration/client-port.js';
 import type { RouteContext } from './individual-onboarding.js';
 export type OrganizationEmployeeCreationInput = {
@@ -116,34 +115,18 @@ export type LicenseOrderRuntimeSearchInput = {
  * - disable is `individual/org.schema/Organization/_disable`
  * - purge is `individual/org.schema/Organization/_purge`
  */
-export type IndividualOrganizationLifecycleInput = {
-    /**
-     * Canonical claims used by GW CORE to locate the hosted individual/family
-     * registration.
-     */
-    organizationClaims?: Record<string, unknown>;
-    /**
-     * Preferred high-level shared editor for lifecycle callers that want to
-     * avoid assembling raw claims inline.
-     */
-    organizationEditor?: IndividualOrganizationLifecycleEditor;
-    /**
-     * Optional canonical resource id when already known by the caller.
-     */
-    resourceId?: string;
-    dataType?: string;
-};
 /**
- * Forward-looking locator payload for a future individual-member lifecycle contract.
+ * Current locator payload for individual-member / caregiver lifecycle
+ * operations backed by `RelatedPerson`.
  *
- * Current GW CORE does not yet expose a stable lifecycle contract for
- * `RelatedPerson` / individual-member records. The Node SDK keeps this type so
- * controller-only methods and TDD can be prepared without fabricating backend behavior.
+ * Current runtime behavior:
+ * - disable uses `RelatedPerson/_batch` with identifier-first lifecycle
+ *   resource semantics
+ * - purge uses explicit `RelatedPerson/_purge`
  */
 export type IndividualMemberLifecycleInput = {
     /**
-     * Canonical claims expected to locate the member/caregiver relationship once
-     * GW CORE exposes the lifecycle contract.
+     * Canonical claims used to locate the member/caregiver relationship.
      */
     memberClaims: Record<string, unknown>;
     resourceId?: string;

package/dist/resource-operations.js

@@ -125,6 +125,7 @@ export async function disableIndividualOrganizationWithDeps(routeCtx, input, opt
         routeCtx,
         requestType: input.dataType || GwCoreLifecycleRequestType.IndividualOrganizationDisable,
         organizationClaims: input.organizationClaims,
+        individualEditor: input.individualEditor,
         organizationEditor: input.organizationEditor,
         resourceId: input.resourceId,
         thidPrefix: 'individual-organization-disable',
@@ -136,6 +137,7 @@ export async function purgeIndividualOrganizationWithDeps(routeCtx, input, optio
         routeCtx,
         requestType: input.dataType || GwCoreLifecycleRequestType.IndividualOrganizationPurge,
         organizationClaims: input.organizationClaims,
+        individualEditor: input.individualEditor,
         organizationEditor: input.organizationEditor,
         resourceId: input.resourceId,
         thidPrefix: 'individual-organization-purge',
@@ -438,8 +440,9 @@ function buildEmployeeLifecyclePayload(input) {
     };
 }
 function buildIndividualOrganizationLifecyclePayload(input) {
-    const payload = input.organizationEditor
-        ? new IndividualOrganizationLifecycleEditor(input.organizationEditor.getState())
+    const editor = input.individualEditor || input.organizationEditor;
+    const payload = editor
+        ? new IndividualOrganizationLifecycleEditor(editor.getState())
         : new IndividualOrganizationLifecycleEditor().setClaims(input.organizationClaims || {});
     payload
         .setRequestType(input.requestType)

package/dist/runtime-client-paths.d.ts

@@ -0,0 +1,79 @@
+import type { HostRouteContext } from './host-onboarding.js';
+import type { RouteContext } from './individual-onboarding.js';
+export declare class RuntimeClientPaths {
+    private readonly defaultCtx?;
+    private readonly warningState;
+    constructor(defaultCtx?: RouteContext);
+    requireRouteContext(ctx?: RouteContext): RouteContext;
+    routeCtxFromInput(input: {
+        serviceProviderDid?: string;
+        tenantId?: string;
+        jurisdiction?: string;
+        sector?: string;
+    }): RouteContext;
+    requireHostRouteContext(ctx?: HostRouteContext): HostRouteContext;
+    v1Path(ctx: RouteContext | undefined, section: string, format: string, resourceType: string, action: string): string;
+    hostRegistryPath(ctx: HostRouteContext | undefined, resourceType: string, action: string): string;
+    hostRegistryOrganizationTransactionPath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationTransactionPollPath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationIssuePath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationIssuePollPath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationActivatePath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationActivatePollPath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationDisablePath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationDisablePollPath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationPurgePath(ctx?: HostRouteContext): string;
+    hostRegistryOrganizationPurgePollPath(ctx?: HostRouteContext): string;
+    hostRegistryOrderBatchPath(ctx?: HostRouteContext): string;
+    hostRegistryOrderPollPath(ctx?: HostRouteContext): string;
+    employeeBatchPath(ctx?: RouteContext): string;
+    employeePollPath(ctx?: RouteContext): string;
+    employeeSearchPath(ctx?: RouteContext): string;
+    employeeSearchPollPath(ctx?: RouteContext): string;
+    organizationLicenseSearchPath(ctx?: RouteContext): string;
+    organizationLicenseSearchPollPath(ctx?: RouteContext): string;
+    organizationDidBindingPath(ctx?: RouteContext): string;
+    organizationDidBindingPollPath(ctx?: RouteContext): string;
+    organizationLicenseOfferSearchPath(ctx?: RouteContext): string;
+    organizationLicenseOfferSearchPollPath(ctx?: RouteContext): string;
+    organizationLicenseOrderSearchPath(ctx?: RouteContext): string;
+    organizationLicenseOrderSearchPollPath(ctx?: RouteContext): string;
+    employeePurgePath(ctx?: RouteContext): string;
+    employeePurgePollPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationBatchPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationPollPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationSearchPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationSearchPollPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationTransactionPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationTransactionPollPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationDisablePath(ctx?: RouteContext): string;
+    individualFamilyOrganizationDisablePollPath(ctx?: RouteContext): string;
+    individualFamilyOrganizationPurgePath(ctx?: RouteContext): string;
+    individualFamilyOrganizationPurgePollPath(ctx?: RouteContext): string;
+    individualLicenseSearchPath(ctx?: RouteContext): string;
+    individualLicenseSearchPollPath(ctx?: RouteContext): string;
+    individualLicenseOfferSearchPath(ctx?: RouteContext): string;
+    individualLicenseOfferSearchPollPath(ctx?: RouteContext): string;
+    individualLicenseOrderSearchPath(ctx?: RouteContext): string;
+    individualLicenseOrderSearchPollPath(ctx?: RouteContext): string;
+    individualFamilyOrderBatchPath(ctx?: RouteContext): string;
+    individualFamilyOrderPollPath(ctx?: RouteContext): string;
+    individualRelatedPersonBatchPath(ctx?: RouteContext): string;
+    individualRelatedPersonPollPath(ctx?: RouteContext): string;
+    individualRelatedPersonPurgePath(ctx?: RouteContext): string;
+    individualRelatedPersonPurgePollPath(ctx?: RouteContext): string;
+    individualConsentR4BatchPath(ctx: RouteContext): string;
+    individualConsentR4PollPath(ctx: RouteContext): string;
+    individualCommunicationBatchPath(ctx: RouteContext, format: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4'): string;
+    individualCommunicationPollPath(ctx: RouteContext, format: 'org.hl7.fhir.api' | 'org.hl7.fhir.r4'): string;
+    individualCommunicationSearchPath(ctx: RouteContext): string;
+    individualCommunicationSearchPollPath(ctx: RouteContext): string;
+    individualBundleSearchPath(ctx: RouteContext): string;
+    individualBundleSearchPollPath(ctx: RouteContext): string;
+    identityTokenExchangePath(ctx: RouteContext): string;
+    identityTokenExchangePollPath(ctx: RouteContext): string;
+    identityDeviceDcrPath(ctx: RouteContext): string;
+    identityDeviceDcrPollPath(ctx: RouteContext): string;
+    identityOpenIdSmartTokenPath(ctx: RouteContext): string;
+    identityOpenIdSmartTokenPollPath(ctx: RouteContext): string;
+}

package/dist/runtime-client-paths.js

@@ -0,0 +1,93 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { GwCoreLifecycleAction } from './constants/lifecycle.js';
+import { buildHostRegistryPath, buildIdentityDeviceDcrPath, buildIdentityDeviceDcrPollPath, buildIdentityOpenIdSmartTokenPath, buildIdentityOpenIdSmartTokenPollPath, buildIdentityTokenExchangePath, buildIdentityTokenExchangePollPath, buildOrganizationDidBindingPath, buildOrganizationDidBindingPollPath, buildV1Path, } from './runtime-paths.js';
+import { requireHostRouteContext, requireRouteContext, routeCtxFromInput, } from './runtime-route-context.js';
+export class RuntimeClientPaths {
+    constructor(defaultCtx) {
+        this.warningState = {
+            warnedDefaultHostNetwork: false,
+        };
+        this.defaultCtx = defaultCtx;
+    }
+    requireRouteContext(ctx) {
+        return requireRouteContext(ctx, this.defaultCtx);
+    }
+    routeCtxFromInput(input) {
+        return routeCtxFromInput(input, this.defaultCtx);
+    }
+    requireHostRouteContext(ctx) {
+        return requireHostRouteContext(ctx, {
+            defaultJurisdiction: this.defaultCtx?.jurisdiction,
+            warningState: this.warningState,
+            warn: (message) => console.warn(message),
+        });
+    }
+    v1Path(ctx, section, format, resourceType, action) {
+        return buildV1Path(this.requireRouteContext(ctx), section, format, resourceType, action);
+    }
+    hostRegistryPath(ctx, resourceType, action) {
+        return buildHostRegistryPath(this.requireHostRouteContext(ctx), resourceType, action);
+    }
+    hostRegistryOrganizationTransactionPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.Transaction); }
+    hostRegistryOrganizationTransactionPollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.TransactionResponse); }
+    hostRegistryOrganizationIssuePath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.Issue); }
+    hostRegistryOrganizationIssuePollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.IssueResponse); }
+    hostRegistryOrganizationActivatePath(ctx) { return this.hostRegistryPath(ctx, 'Organization', '_activate'); }
+    hostRegistryOrganizationActivatePollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', '_activate-response'); }
+    hostRegistryOrganizationDisablePath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.Disable); }
+    hostRegistryOrganizationDisablePollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', `${GwCoreLifecycleAction.Disable}-response`); }
+    hostRegistryOrganizationPurgePath(ctx) { return this.hostRegistryPath(ctx, 'Organization', GwCoreLifecycleAction.Purge); }
+    hostRegistryOrganizationPurgePollPath(ctx) { return this.hostRegistryPath(ctx, 'Organization', `${GwCoreLifecycleAction.Purge}-response`); }
+    hostRegistryOrderBatchPath(ctx) { return this.hostRegistryPath(ctx, 'Order', '_batch'); }
+    hostRegistryOrderPollPath(ctx) { return this.hostRegistryPath(ctx, 'Order', '_batch-response'); }
+    employeeBatchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', GwCoreLifecycleAction.Batch); }
+    employeePollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', GwCoreLifecycleAction.BatchResponse); }
+    employeeSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', '_search'); }
+    employeeSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', '_search-response'); }
+    organizationLicenseSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'License', '_search'); }
+    organizationLicenseSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'License', '_search-response'); }
+    organizationDidBindingPath(ctx) { return buildOrganizationDidBindingPath(this.requireRouteContext(ctx)); }
+    organizationDidBindingPollPath(ctx) { return buildOrganizationDidBindingPollPath(this.requireRouteContext(ctx)); }
+    organizationLicenseOfferSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Offer', '_search'); }
+    organizationLicenseOfferSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Offer', '_search-response'); }
+    organizationLicenseOrderSearchPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Order', '_search'); }
+    organizationLicenseOrderSearchPollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Order', '_search-response'); }
+    employeePurgePath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', GwCoreLifecycleAction.Purge); }
+    employeePurgePollPath(ctx) { return this.v1Path(ctx, 'entity', 'org.schema', 'Employee', `${GwCoreLifecycleAction.Purge}-response`); }
+    individualFamilyOrganizationBatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.Batch); }
+    individualFamilyOrganizationPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.BatchResponse); }
+    individualFamilyOrganizationSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', '_search'); }
+    individualFamilyOrganizationSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', '_search-response'); }
+    individualFamilyOrganizationTransactionPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.Transaction); }
+    individualFamilyOrganizationTransactionPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.TransactionResponse); }
+    individualFamilyOrganizationDisablePath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.Disable); }
+    individualFamilyOrganizationDisablePollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', `${GwCoreLifecycleAction.Disable}-response`); }
+    individualFamilyOrganizationPurgePath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', GwCoreLifecycleAction.Purge); }
+    individualFamilyOrganizationPurgePollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Organization', `${GwCoreLifecycleAction.Purge}-response`); }
+    individualLicenseSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'License', '_search'); }
+    individualLicenseSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'License', '_search-response'); }
+    individualLicenseOfferSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Offer', '_search'); }
+    individualLicenseOfferSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Offer', '_search-response'); }
+    individualLicenseOrderSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_search'); }
+    individualLicenseOrderSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_search-response'); }
+    individualFamilyOrderBatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_batch'); }
+    individualFamilyOrderPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.schema', 'Order', '_batch-response'); }
+    individualRelatedPersonBatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_batch'); }
+    individualRelatedPersonPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_batch-response'); }
+    individualRelatedPersonPurgePath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_purge'); }
+    individualRelatedPersonPurgePollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'RelatedPerson', '_purge-response'); }
+    individualConsentR4BatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Consent', '_batch'); }
+    individualConsentR4PollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Consent', '_batch-response'); }
+    individualCommunicationBatchPath(ctx, format) { return this.v1Path(ctx, 'individual', format, 'Communication', '_batch'); }
+    individualCommunicationPollPath(ctx, format) { return this.v1Path(ctx, 'individual', format, 'Communication', '_batch-response'); }
+    individualCommunicationSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Communication', '_search'); }
+    individualCommunicationSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Communication', '_search-response'); }
+    individualBundleSearchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Bundle', '_search'); }
+    individualBundleSearchPollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'Bundle', '_search-response'); }
+    identityTokenExchangePath(ctx) { return buildIdentityTokenExchangePath(ctx); }
+    identityTokenExchangePollPath(ctx) { return buildIdentityTokenExchangePollPath(ctx); }
+    identityDeviceDcrPath(ctx) { return buildIdentityDeviceDcrPath(ctx); }
+    identityDeviceDcrPollPath(ctx) { return buildIdentityDeviceDcrPollPath(ctx); }
+    identityOpenIdSmartTokenPath(ctx) { return buildIdentityOpenIdSmartTokenPath(ctx); }
+    identityOpenIdSmartTokenPollPath(ctx) { return buildIdentityOpenIdSmartTokenPollPath(ctx); }
+}

package/dist/runtime-consent.d.ts

@@ -0,0 +1,7 @@
+import type { GrantProfessionalAccessInput } from './resource-operations.js';
+export declare function buildGrantProfessionalAccessClaimsWithCid(input: GrantProfessionalAccessInput, createRuntimeUuid: () => string): {
+    actorIdentifier: string;
+    subjectIdentifier: string;
+    consentClaims: Record<string, unknown>;
+    claimsCid?: string;
+};

package/dist/runtime-consent.js

@@ -0,0 +1,21 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { buildConsentClaimsSimpleWithCid } from 'gdc-common-utils-ts/utils/consent';
+export function buildGrantProfessionalAccessClaimsWithCid(input, createRuntimeUuid) {
+    return buildConsentClaimsSimpleWithCid({
+        subjectDid: input.subjectDid,
+        subjectPhone: input.subjectPhone,
+        subjectGivenName: input.subjectGivenName,
+        actor: input.actorId ?? input.actor ?? '',
+        actorRole: String(input?.actorRole || ''),
+        purpose: String(input?.purpose || ''),
+        actions: Array.isArray(input?.actions) ? input.actions : [],
+        consentIdentifier: input.consentIdentifier,
+        consentDate: input.consentDate,
+        decision: input.decision,
+        attachmentContentType: input.attachmentContentType,
+        attachmentBase64: input.attachmentBase64,
+    }, {
+        errorPrefix: 'grantProfessionalAccess:',
+        consentIdentifierFactory: () => `urn:uuid:${createRuntimeUuid()}`,
+    });
+}

package/dist/runtime-host-submission.d.ts

@@ -0,0 +1,62 @@
+import type { OrganizationDidBindingInput } from 'gdc-sdk-core-ts';
+import type { OrganizationActivationDraft } from 'gdc-sdk-core-ts';
+import { buildLegalOrganizationVerificationGatewayRequestBundle } from 'gdc-sdk-core-ts';
+import type { HostRouteContext } from './host-onboarding.js';
+import type { NodeLegalOrganizationVerificationTransactionInput, NodeOrganizationActivationInput, NodeOrganizationDidBindingInput, PollOptions, SubmitAndPollResult, SubmitPayload } from './orchestration/client-port.js';
+import type { RouteContext } from './individual-onboarding.js';
+type SubmitAndPollMethod = (submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions) => Promise<SubmitAndPollResult>;
+export declare function submitLegalOrganizationVerificationTransactionWithDeps(input: {
+    hostCtx: HostRouteContext;
+    verificationInput: NodeLegalOrganizationVerificationTransactionInput;
+    pollOptions?: PollOptions;
+    createRuntimeUuid: () => string;
+    wrapBundleAsGatewayTransactionMessage: (input: {
+        thid: string;
+        jti: string;
+        hostCtx: HostRouteContext;
+        bundle: ReturnType<typeof buildLegalOrganizationVerificationGatewayRequestBundle>;
+    }) => SubmitPayload;
+    submitPath: (ctx: HostRouteContext) => string;
+    pollPath: (ctx: HostRouteContext) => string;
+    submitAndPoll: SubmitAndPollMethod;
+}): Promise<SubmitAndPollResult>;
+export declare function submitLegalOrganizationIssueWithDeps(input: {
+    hostCtx: HostRouteContext;
+    verificationInput: NodeLegalOrganizationVerificationTransactionInput;
+    pollOptions?: PollOptions;
+    createRuntimeUuid: () => string;
+    wrapBundleAsGatewayTransactionMessage: (input: {
+        thid: string;
+        jti: string;
+        hostCtx: HostRouteContext;
+        bundle: ReturnType<typeof buildLegalOrganizationVerificationGatewayRequestBundle>;
+    }) => SubmitPayload;
+    submitPath: (ctx: HostRouteContext) => string;
+    pollPath: (ctx: HostRouteContext) => string;
+    submitAndPoll: SubmitAndPollMethod;
+}): Promise<SubmitAndPollResult>;
+export declare function submitOrganizationDidBindingWithDeps(input: {
+    routeCtx: RouteContext;
+    bindingInput: NodeOrganizationDidBindingInput | OrganizationDidBindingInput;
+    pollOptions?: PollOptions;
+    createRuntimeUuid: () => string;
+    organizationDidBindingPath: (ctx: RouteContext) => string;
+    organizationDidBindingPollPath: (ctx: RouteContext) => string;
+    submitAndPoll: SubmitAndPollMethod;
+}): Promise<SubmitAndPollResult>;
+export declare function activateOrganizationInGatewayFromIcaProofWithDeps(input: {
+    hostCtx: HostRouteContext;
+    activationInput: NodeOrganizationActivationInput;
+    pollOptions?: PollOptions;
+    createRuntimeUuid: () => string;
+    activationDraftFactory: (input: {
+        vpToken: string;
+        controller?: NodeOrganizationActivationInput['controller'];
+        service?: NodeOrganizationActivationInput['service'];
+        additionalClaims?: NodeOrganizationActivationInput['additionalClaims'];
+    }) => OrganizationActivationDraft;
+    submitPath: (ctx: HostRouteContext) => string;
+    pollPath: (ctx: HostRouteContext) => string;
+    submitAndPoll: SubmitAndPollMethod;
+}): Promise<SubmitAndPollResult>;
+export {};

package/dist/runtime-host-submission.js

@@ -0,0 +1,82 @@
+import { buildLegalOrganizationVerificationGatewayRequestBundle, buildOrganizationDidBindingBundle, } from 'gdc-sdk-core-ts';
+import { buildDidcommPlaintextTransportMetadata } from 'gdc-common-utils-ts/utils/activation-request';
+export async function submitLegalOrganizationVerificationTransactionWithDeps(input) {
+    const thid = `organization-verification-transaction-${input.createRuntimeUuid()}`;
+    const jti = `organization-verification-transaction-jti-${input.createRuntimeUuid()}`;
+    const verificationBundle = buildLegalOrganizationVerificationGatewayRequestBundle(input.verificationInput);
+    const payload = input.wrapBundleAsGatewayTransactionMessage({
+        thid,
+        jti,
+        hostCtx: input.hostCtx,
+        bundle: verificationBundle,
+    });
+    return input.submitAndPoll(input.submitPath(input.hostCtx), input.pollPath(input.hostCtx), payload, input.pollOptions);
+}
+export async function submitLegalOrganizationIssueWithDeps(input) {
+    const thid = `organization-issue-${input.createRuntimeUuid()}`;
+    const jti = `organization-issue-jti-${input.createRuntimeUuid()}`;
+    const verificationBundle = buildLegalOrganizationVerificationGatewayRequestBundle(input.verificationInput);
+    const payload = input.wrapBundleAsGatewayTransactionMessage({
+        thid,
+        jti,
+        hostCtx: input.hostCtx,
+        bundle: verificationBundle,
+    });
+    return input.submitAndPoll(input.submitPath(input.hostCtx), input.pollPath(input.hostCtx), payload, input.pollOptions);
+}
+export async function submitOrganizationDidBindingWithDeps(input) {
+    const thid = `organization-did-binding-${input.createRuntimeUuid()}`;
+    const jti = `organization-did-binding-jti-${input.createRuntimeUuid()}`;
+    const payload = {
+        jti,
+        thid,
+        type: 'application/api+json',
+        body: buildOrganizationDidBindingBundle(input.bindingInput),
+    };
+    return input.submitAndPoll(input.organizationDidBindingPath(input.routeCtx), input.organizationDidBindingPollPath(input.routeCtx), payload, input.pollOptions);
+}
+export async function activateOrganizationInGatewayFromIcaProofWithDeps(input) {
+    const thid = `activate-org-${input.createRuntimeUuid()}`;
+    const activationDraft = input.activationDraftFactory({
+        vpToken: input.activationInput.vpToken,
+        controller: input.activationInput.controller,
+        service: input.activationInput.service,
+        additionalClaims: input.activationInput.additionalClaims,
+    });
+    const serviceClaims = activationDraft.buildServiceClaims();
+    const transportMeta = buildDidcommPlaintextTransportMetadata({
+        controller: input.activationInput.controller,
+        contentType: 'application/didcomm-plain+json',
+    });
+    const payload = {
+        thid,
+        iss: String(input.hostCtx.controllerDid || '').trim() || undefined,
+        aud: String(input.hostCtx.hostDid || '').trim() || undefined,
+        type: 'application/api+json',
+        ...(transportMeta ? { meta: transportMeta } : {}),
+        body: {
+            vp_token: input.activationInput.vpToken,
+            ...(input.activationInput.controller ? { controller: input.activationInput.controller } : {}),
+            data: [{
+                    type: 'Organization-activation-request-v1.0',
+                    meta: {
+                        claims: {
+                            '@context': 'org.schema',
+                            ...serviceClaims,
+                            ...(input.activationInput.additionalClaims || {}),
+                        },
+                    },
+                    resource: {
+                        meta: {
+                            claims: {
+                                '@context': 'org.schema',
+                                ...serviceClaims,
+                                ...(input.activationInput.additionalClaims || {}),
+                            },
+                        },
+                    },
+                }],
+        },
+    };
+    return input.submitAndPoll(input.submitPath(input.hostCtx), input.pollPath(input.hostCtx), payload, input.pollOptions);
+}

package/dist/runtime-http-trace.d.ts

@@ -0,0 +1,4 @@
+export declare function appendHttpTrace(traceFile: string | undefined, entry: Record<string, unknown>): void;
+export declare function parseTraceBody(body: BodyInit | null | undefined): unknown;
+export declare function parseTraceRawText(raw: string): unknown;
+export declare function redactTraceValue<T>(value: T): T;