gdc-sdk-node-ts 2.1.1 → 2.2.2

package/dist/resource-operations.d.ts

@@ -1,7 +1,7 @@
-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 { BundleEntry, BundleJsonApi } from 'gdc-common-utils-ts/models/bundle';
 import type { SubmitAndPollResult } from './orchestration/client-port.js';
 import type { RouteContext } from './individual-onboarding.js';
 export type OrganizationEmployeeCreationInput = {
@@ -116,34 +116,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;
@@ -177,6 +161,53 @@ export type CommunicationIngestionInput = {
         intervalMs?: number;
     };
 };
+export type BlockchainArtifactRegistrationInput = {
+    subject: string;
+    resource?: Record<string, unknown>;
+    contentDataBase64?: string;
+    contentType?: string;
+    identifier?: string;
+    title?: string;
+    description?: string;
+    date?: string;
+    location?: string;
+    language?: string;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+};
+export type BlockchainArtifactSearchSelectionInput = Readonly<{
+    subject: string;
+    searchResponse: unknown;
+    selectedResourceIds?: readonly string[];
+}>;
+export type BlockchainArtifactSearchSelectionResult = Readonly<{
+    availableResourceIds: readonly string[];
+    anchoredResourceIds: readonly string[];
+    unanchoredResourceIds: readonly string[];
+    selectedResourceIds: readonly string[];
+    missingResourceIds: readonly string[];
+    returnedCount: number;
+    totalCount: number;
+    bundle: BundleJsonApi<BundleEntry>;
+}>;
+export type VitalSignBatchCommunicationFromSearchResponseInput = Readonly<{
+    subject: string;
+    searchResponse: unknown;
+    selectedResourceIds?: readonly string[];
+    sender?: string;
+    recipient?: string | string[];
+    sent?: string;
+    status?: string;
+    noteText?: string;
+    requestThid?: string;
+    pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    };
+}>;
 /**
  * Runtime participant query for `Communication/_search`.
  *
@@ -549,11 +580,37 @@ export declare function searchClinicalBundleWithDeps(routeCtx: RouteContext, inp
         intervalMs?: number;
     }) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+/**
+ * Builds one Communication-ready ingestion payload from a paginated search
+ * response that already selected the day batches to be anchored.
+ *
+ * The search response is normalized into a `Bundle.type=batch` attachment,
+ * and the resulting `Communication` is ready for `ingestCommunication...`.
+ */
+export declare function buildVitalSignBatchCommunicationFromSearchResponse(input: VitalSignBatchCommunicationFromSearchResponseInput): CommunicationIngestionInput;
+/**
+ * Builds one blockchain-ready batch bundle from a paginated search response.
+ *
+ * The helper keeps the original search result as the source of truth and only
+ * projects the selected `resource.id` values into a `Bundle.type=batch`
+ * payload for subsequent communication/registration.
+ */
+export declare function buildBlockchainArtifactBundleFromSearchResponse(input: BlockchainArtifactSearchSelectionInput): BlockchainArtifactSearchSelectionResult;
 export declare function searchLatestIpsWithDeps(routeCtx: RouteContext, input: Omit<ClinicalBundleSearchInput, 'includedTypes' | 'section'> & {
     section?: string | string[];
 }, deps: {
     searchClinicalBundle: (routeCtx: RouteContext, input: ClinicalBundleSearchInput) => Promise<SubmitAndPollResult>;
 }): Promise<SubmitAndPollResult>;
+export declare function registerBlockchainArtifactAndUpdateIndexWithDeps(routeCtx: RouteContext, input: BlockchainArtifactRegistrationInput, deps: {
+    individualDocumentReferenceBatchPath: (ctx: RouteContext) => string;
+    individualDocumentReferencePollPath: (ctx: RouteContext) => string;
+    submitAndPoll: (submitPath: string, pollPath: string, payload: {
+        thid?: string;
+    } & Record<string, unknown>, pollOptions?: {
+        timeoutMs?: number;
+        intervalMs?: number;
+    }) => Promise<SubmitAndPollResult>;
+}): Promise<SubmitAndPollResult>;
 export declare function grantProfessionalAccessWithDeps(routeCtx: RouteContext, input: GrantProfessionalAccessInput, deps: {
     buildConsentClaimsWithCid: (input: GrantProfessionalAccessInput, options?: {
         consentIdentifierFactory: () => string;

package/dist/resource-operations.js

@@ -2,7 +2,8 @@
 import { HealthcareBasicSections, ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants';
 import { Format } from 'gdc-common-utils-ts/constants/Schemas';
 import { RelatedPersonClaim } from 'gdc-common-utils-ts/models/interoperable-claims/related-person-claims';
-import { buildCommunicationParticipantSearchBundle, createInteroperableResourceOperationEditor, IndividualOrganizationLifecycleEditor, LicenseOfferSearchEditor, LicenseOrderSearchEditor, InteroperableLifecycleStatuses, LicenseListSearchEditor, } from 'gdc-common-utils-ts';
+import { buildCommunicationParticipantSearchBundle, buildBlockchainArtifactDocumentReference, BundleQuery, createInteroperableResourceOperationEditor, IndividualOrganizationLifecycleEditor, LicenseOfferSearchEditor, LicenseOrderSearchEditor, InteroperableLifecycleStatuses, LicenseListSearchEditor, } from 'gdc-common-utils-ts';
+import { addFhirResourceToCommunication, createCommunicationResource, } from 'gdc-sdk-core-ts';
 import { GwCoreLifecycleRequestMethod, GwCoreLifecycleRequestType, GwCoreLifecycleTodo, } from './constants/lifecycle.js';
 import { buildEmployeeBatchEntry, buildEmployeeSearchBundle, ConsentClaims, } from 'gdc-sdk-core-ts';
 export async function createOrganizationEmployeeWithDeps(routeCtx, input, options, deps) {
@@ -125,6 +126,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 +138,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',
@@ -321,6 +324,117 @@ export async function searchClinicalBundleWithDeps(routeCtx, input, deps) {
     };
     return deps.submitAndPoll(deps.bundleSearchPath(routeCtx), deps.bundleSearchPollPath(routeCtx), payload, input.pollOptions);
 }
+/**
+ * Builds one Communication-ready ingestion payload from a paginated search
+ * response that already selected the day batches to be anchored.
+ *
+ * The search response is normalized into a `Bundle.type=batch` attachment,
+ * and the resulting `Communication` is ready for `ingestCommunication...`.
+ */
+export function buildVitalSignBatchCommunicationFromSearchResponse(input) {
+    const selection = buildBlockchainArtifactBundleFromSearchResponse({
+        subject: input.subject,
+        searchResponse: input.searchResponse,
+        selectedResourceIds: input.selectedResourceIds,
+    });
+    const communication = addFhirResourceToCommunication(createCommunicationResource({
+        subject: input.subject,
+        sender: input.sender,
+        recipient: input.recipient,
+        sent: input.sent,
+        status: input.status || 'completed',
+        noteText: input.noteText || `Selected ${selection.selectedResourceIds.length} vital-sign batch item(s) for blockchain anchoring.`,
+        claims: {
+            'Communication.vital-sign-batch-selection.subject': input.subject,
+            'Communication.vital-sign-batch-selection.selected-count': selection.selectedResourceIds.length,
+            'Communication.vital-sign-batch-selection.unanchored-count': selection.unanchoredResourceIds.length,
+            'Communication.vital-sign-batch-selection.selected-ids': selection.selectedResourceIds.join(','),
+            'Communication.vital-sign-batch-selection.missing-ids': selection.missingResourceIds.join(','),
+        },
+    }), selection.bundle, {
+        attachmentContentType: 'application/fhir+json',
+        attachmentTitle: 'vital-sign-batch-selection.json',
+    });
+    return {
+        communicationPayload: communication,
+        pathFormatSegment: 'org.hl7.fhir.r4',
+        pollOptions: input.pollOptions,
+        autoConvertClaimsToFhirR4: false,
+    };
+}
+/**
+ * Builds one blockchain-ready batch bundle from a paginated search response.
+ *
+ * The helper keeps the original search result as the source of truth and only
+ * projects the selected `resource.id` values into a `Bundle.type=batch`
+ * payload for subsequent communication/registration.
+ */
+export function buildBlockchainArtifactBundleFromSearchResponse(input) {
+    const bundle = normalizeBundleLike(input.searchResponse);
+    const query = new BundleQuery(bundle);
+    const availableResourceIds = query.getResourceIds();
+    const availableEntries = query.getResourceEntriesByIds(availableResourceIds);
+    const anchoredResourceIds = availableEntries
+        .filter((entry) => hasAuditTxId(entry))
+        .map((entry, index) => resolveBundleEntryStableId(entry, index));
+    const unanchoredResourceIds = availableResourceIds.filter((resourceId) => !anchoredResourceIds.includes(resourceId));
+    const requestedResourceIds = normalizeIdList(input.selectedResourceIds);
+    const selectedResourceIds = requestedResourceIds.length > 0
+        ? requestedResourceIds.filter((resourceId) => availableResourceIds.includes(resourceId))
+        : unanchoredResourceIds;
+    const missingResourceIds = requestedResourceIds.filter((resourceId) => !availableResourceIds.includes(resourceId));
+    if (requestedResourceIds.length > 0 && selectedResourceIds.length === 0) {
+        throw new Error('buildBlockchainArtifactBundleFromSearchResponse could not match any selected resource ids.');
+    }
+    const selectedEntries = query.getResourceEntriesByIds(selectedResourceIds);
+    const artifactEntries = selectedEntries.map((entry, index) => {
+        const resource = entry.resource && typeof entry.resource === 'object' ? entry.resource : undefined;
+        if (!resource) {
+            throw new Error(`buildBlockchainArtifactBundleFromSearchResponse requires resource data for selected entry at index ${index}.`);
+        }
+        const logicalIdentifier = asTrimmedString(resource.id || entry.id || entry.fullUrl || selectedResourceIds[index]);
+        const artifact = buildBlockchainArtifactDocumentReference({
+            subject: input.subject,
+            resource,
+            identifier: logicalIdentifier || undefined,
+            title: `${asTrimmedString(resource.resourceType) || 'resource'}.json`,
+        });
+        return {
+            type: 'DocumentReference',
+            meta: { claims: artifact.documentReference.meta?.claims || {} },
+            resource: artifact.documentReference,
+            request: {
+                method: 'POST',
+                url: 'individual/org.hl7.fhir.r4/DocumentReference/_batch',
+            },
+        };
+    });
+    return {
+        availableResourceIds,
+        anchoredResourceIds,
+        unanchoredResourceIds,
+        selectedResourceIds,
+        missingResourceIds,
+        returnedCount: query.getResourceIds().length,
+        totalCount: typeof bundle.total === 'number'
+            ? Number(bundle.total)
+            : query.getResourceIds().length,
+        bundle: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            meta: {
+                claims: {
+                    'BlockchainArtifactSelection.subject': input.subject,
+                    'BlockchainArtifactSelection.availableCount': availableResourceIds.length,
+                    'BlockchainArtifactSelection.selectedCount': selectedResourceIds.length,
+                    'BlockchainArtifactSelection.missingCount': missingResourceIds.length,
+                    'BlockchainArtifactSelection.selectedResourceIds': selectedResourceIds.join(','),
+                },
+            },
+            data: artifactEntries,
+        },
+    };
+}
 export async function searchLatestIpsWithDeps(routeCtx, input, deps) {
     return deps.searchClinicalBundle(routeCtx, {
         ...input,
@@ -328,6 +442,78 @@ export async function searchLatestIpsWithDeps(routeCtx, input, deps) {
         includedTypes: ['Composition', 'DocumentReference'],
     });
 }
+export async function registerBlockchainArtifactAndUpdateIndexWithDeps(routeCtx, input, deps) {
+    const artifact = buildBlockchainArtifactDocumentReference({
+        subject: input.subject,
+        resource: input.resource,
+        contentDataBase64: input.contentDataBase64,
+        contentType: input.contentType,
+        identifier: input.identifier,
+        title: input.title,
+        description: input.description,
+        date: input.date,
+        location: input.location,
+        language: input.language,
+    });
+    const payload = {
+        thid: input.requestThid || `blockchain-artifact-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [{
+                    type: 'DocumentReference',
+                    meta: { claims: artifact.documentReference.meta?.claims || {} },
+                    resource: artifact.documentReference,
+                    request: {
+                        method: 'POST',
+                        url: 'individual/org.hl7.fhir.r4/DocumentReference/_batch',
+                    },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.individualDocumentReferenceBatchPath(routeCtx), deps.individualDocumentReferencePollPath(routeCtx), payload, input.pollOptions);
+}
+function normalizeBundleLike(value) {
+    const root = value && typeof value === 'object' ? value : {};
+    const body = root.body && typeof root.body === 'object' ? root.body : root;
+    const resourceType = asTrimmedString(body.resourceType) || 'Bundle';
+    const type = asTrimmedString(body.type) || 'batch';
+    const data = Array.isArray(body.data)
+        ? body.data
+        : (Array.isArray(body.entry) ? body.entry : []);
+    return {
+        ...(typeof body.id === 'string' ? { id: asTrimmedString(body.id) || undefined } : {}),
+        resourceType: resourceType,
+        type,
+        total: typeof body.total === 'number' ? body.total : undefined,
+        meta: body.meta && typeof body.meta === 'object' ? body.meta : undefined,
+        data: data,
+    };
+}
+function normalizeIdList(value) {
+    return [...(value || [])]
+        .map((item) => asTrimmedString(item))
+        .filter(Boolean);
+}
+function asTrimmedString(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    return String(value).trim();
+}
+function resolveBundleEntryStableId(entry, index) {
+    const resource = entry.resource && typeof entry.resource === 'object' ? entry.resource : {};
+    return asTrimmedString(resource.id || entry.id || entry.fullUrl || `entry-${index}`);
+}
+function hasAuditTxId(entry) {
+    const entryAudit = entry && typeof entry === 'object' ? entry.audit : undefined;
+    const entryMeta = entry && typeof entry === 'object' ? entry.meta : undefined;
+    const resource = entry.resource && typeof entry.resource === 'object' ? entry.resource : {};
+    const resourceMeta = resource.meta && typeof resource.meta === 'object' ? resource.meta : {};
+    const audit = [entryAudit, entryMeta && typeof entryMeta === 'object' ? entryMeta.audit : undefined, resourceMeta.audit]
+        .find((candidate) => candidate && typeof candidate === 'object');
+    return Boolean(asTrimmedString(audit?.txId));
+}
 export async function grantProfessionalAccessWithDeps(routeCtx, input, deps) {
     const built = deps.buildConsentClaimsWithCid({
         subjectDid: input.subjectDid,
@@ -438,8 +624,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,81 @@
+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;
+    individualDocumentReferenceBatchPath(ctx: RouteContext): string;
+    individualDocumentReferencePollPath(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,95 @@
+// 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'); }
+    individualDocumentReferenceBatchPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'DocumentReference', '_batch'); }
+    individualDocumentReferencePollPath(ctx) { return this.v1Path(ctx, 'individual', 'org.hl7.fhir.r4', 'DocumentReference', '_batch-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 {};