gdc-sdk-node-ts 2.9.19 → 2.9.21

package/README.md

@@ -663,6 +663,48 @@ export async function GET(request: Request) {
 The application validates which systems are allowed for the specific coded
 form field. This MVP service performs no external terminology request.
 
+### Governed ValueSet options through the terminology service
+
+For creation controls, the authenticated BFF can resolve the ValueSet bound to
+a canonical flat claim without exposing its service token or terminology
+server to the browser:
+
+```ts
+import {
+  AllergyIntoleranceClaim,
+  MemoryTerminologyValueSetCache,
+  TerminologyServiceClient,
+} from 'gdc-sdk-node-ts';
+
+const terminology = new TerminologyServiceClient({
+  baseUrl: process.env.TERMINOLOGY_SERVICE_URL!,
+  serviceToken: process.env.TERMINOLOGY_SERVICE_TOKEN!,
+  cache: new MemoryTerminologyValueSetCache(),
+});
+
+const { document, cacheStatus } = await terminology.expandValueSetForClaim({
+  sector: 'health-care',
+  resourceType: 'AllergyIntolerance',
+  claim: AllergyIntoleranceClaim.Manifestation,
+  // Optional: language, jurisdiction, version, fhirVersion, offset and count.
+});
+```
+
+Omission means English, international/default terminology, the latest
+installed terminology version and FHIR R4. Jurisdiction is a SNOMED edition
+selector; it does not become part of LOINC or WHO ATC identity. The cache key
+still separates language, SNOMED edition/version, claim and page.
+
+`MemoryTerminologyValueSetCache.prime(...)` accepts immutable startup
+snapshots. This permits an application to ship or load the English IPS page
+from private storage and render it without a live terminology call. A local
+language page is preferred when cached; if refresh fails, an English cached
+page is returned with `cacheStatus: 'english-fallback-cache'`. Complete
+catalogs and the service bearer credential remain server-side. A BFF may
+replace the memory implementation with a GCS, Firestore or PostgreSQL adapter
+implementing `TerminologyValueSetCache`; large complete catalogs should not be
+stored in one Firestore document.
+
 ## API Index
 
 ## Full Public Surface

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from 'gdc-sdk-core-ts';
+export { AllergyIntoleranceClaim } from 'gdc-common-utils-ts/models/interoperable-claims/allergy-intolerance-claims';
 export * from './runtime-contracts.js';
 export * from './identity-bootstrap.js';
 export * from './async-polling.js';
@@ -51,4 +52,5 @@ export * from './orchestration/professional-sdk.js';
 export * from './orchestration/digital-twin-sdk.js';
 export * from './legacy-compat.js';
 export * from './local-terminology-bff.js';
+export * from './terminology-service-client.js';
 export * from './pdqm-patient-match.js';

package/dist/index.js

@@ -1,5 +1,7 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 export * from 'gdc-sdk-core-ts';
+// Explicitly use the direct common-utils release for newly promoted canonical claims.
+export { AllergyIntoleranceClaim } from 'gdc-common-utils-ts/models/interoperable-claims/allergy-intolerance-claims';
 export * from './runtime-contracts.js';
 export * from './identity-bootstrap.js';
 export * from './async-polling.js';
@@ -52,4 +54,5 @@ export * from './orchestration/professional-sdk.js';
 export * from './orchestration/digital-twin-sdk.js';
 export * from './legacy-compat.js';
 export * from './local-terminology-bff.js';
+export * from './terminology-service-client.js';
 export * from './pdqm-patient-match.js';

package/dist/organization-registration-authorization.d.ts

@@ -0,0 +1,16 @@
+import type { VerifiableCredentialV2 } from 'gdc-common-utils-ts/models/verifiable-credential';
+import type { IWallet, WalletExecutionContext, WalletKeySelection } from 'gdc-sdk-core-ts';
+/** Input required to add one human-authorizer proof to the out-of-band VC. */
+export type SignOrganizationRegistrationAuthorizationInput = Readonly<{
+    credential: VerifiableCredentialV2;
+    wallet: IWallet;
+    context: WalletExecutionContext;
+    key: WalletKeySelection;
+    verificationMethod: string;
+    createdAt?: string;
+}>;
+/**
+ * Adds one detached JWS proof made by the already-unlocked professional
+ * profile. The browser never receives the private key or clear wallet seed.
+ */
+export declare function signOrganizationRegistrationAuthorizationCredential(input: SignOrganizationRegistrationAuthorizationInput): Promise<VerifiableCredentialV2>;

package/dist/organization-registration-authorization.js

@@ -0,0 +1,34 @@
+import { canonicalizeOrganizationRegistrationAuthorizationCredential, } from 'gdc-common-utils-ts/utils/organization-registration-authorization';
+/**
+ * Adds one detached JWS proof made by the already-unlocked professional
+ * profile. The browser never receives the private key or clear wallet seed.
+ */
+export async function signOrganizationRegistrationAuthorizationCredential(input) {
+    if (!input.wallet.signDetachedJws) {
+        throw new Error('Wallet does not support detached organization authorization proofs.');
+    }
+    const verificationMethod = String(input.verificationMethod || '').trim();
+    if (!verificationMethod)
+        throw new Error('Organization authorization proof requires verificationMethod.');
+    const payload = canonicalizeOrganizationRegistrationAuthorizationCredential(input.credential);
+    const jws = await input.wallet.signDetachedJws(input.context, {
+        payload,
+        header: { typ: 'application/vc+ld+json' },
+        key: input.key,
+    });
+    const existingProofs = Array.isArray(input.credential.proof)
+        ? input.credential.proof
+        : input.credential.proof
+            ? [input.credential.proof]
+            : [];
+    return {
+        ...input.credential,
+        proof: [...existingProofs, {
+                type: 'JsonWebSignature2020',
+                created: input.createdAt || new Date().toISOString(),
+                proofPurpose: 'contractAgreement',
+                verificationMethod,
+                jws,
+            }],
+    };
+}

package/dist/server-profile-session.d.ts

@@ -286,6 +286,8 @@ export type ServerAuthorizedSubjectSelectionInput = Readonly<{
 /** Server-owned relationship projection for one directory subject. */
 export type ServerAuthorizedSubjectGrant = Readonly<{
     subjectDid: string;
+    /** Canonical private subject used for SMART when the directory exposes a public card alias. */
+    transportSubjectDid?: string;
     actorMode: ServerActorMode;
     attester?: ServerProfileAttester;
 }>;

package/dist/server-profile-session.js

@@ -3,6 +3,7 @@ import { randomBytes } from 'node:crypto';
 import { ActorKinds } from 'gdc-common-utils-ts/constants/actor-session';
 import { UrnPrefixes } from 'gdc-common-utils-ts/constants/urn';
 import { normalizeUuid } from 'gdc-common-utils-ts/utils/normalize-uuid';
+import { parseIndividualMemberDidWeb } from 'gdc-common-utils-ts/utils/did';
 import { selectRelatedPersonListRecord, } from 'gdc-common-utils-ts/utils/related-person-list';
 import { CompositionAttesterModes, } from 'gdc-common-utils-ts/models/interoperable-claims/composition-claims';
 import { FhirIpsCreatorKinds, normalizeClinicalCreatorBinding, } from 'gdc-common-utils-ts/utils/fhir-ips-creator-identity';
@@ -619,8 +620,25 @@ export class ServerProfileSessionManager {
         const walletState = await this.resolveWalletState(input.ownerId, input.sessionId);
         const client = this.createRegisteredProfileClient(walletState.profile, walletState.wallet, walletState.context, idToken);
         const subjects = await client.listAuthorizedIndividualSubjects(walletState.profile.routeContext, { verifiedContact: input.verifiedContact });
-        const authorizedSubjectDids = unique(subjects.map((subject) => subject.subjectDid));
-        const authorizedSubjects = subjects.map(toServerAuthorizedSubjectGrant);
+        const directoryGrants = subjects.map(toServerAuthorizedSubjectGrant);
+        const canonicalControllerSubject = canonicalIndividualControllerSubject(actorSession.profile);
+        const enrolledSubjects = new Set(actorSession.profile.allowedSubjectDids);
+        const ownPublicGrant = canonicalControllerSubject && enrolledSubjects.has(canonicalControllerSubject)
+            ? directoryGrants.find((grant) => grant.subjectDid !== canonicalControllerSubject
+                && enrolledSubjects.has(grant.subjectDid)
+                && (grant.actorMode === 'self' || grant.actorMode === 'controller'))
+            : undefined;
+        const authorizedSubjects = ownPublicGrant && canonicalControllerSubject
+            ? [
+                ...directoryGrants.map((grant) => grant === ownPublicGrant
+                    ? { ...grant, transportSubjectDid: canonicalControllerSubject }
+                    : grant),
+                ...(directoryGrants.some((grant) => grant.subjectDid === canonicalControllerSubject)
+                    ? []
+                    : [{ ...ownPublicGrant, subjectDid: canonicalControllerSubject }]),
+            ]
+            : directoryGrants;
+        const authorizedSubjectDids = unique(authorizedSubjects.map((subject) => subject.subjectDid));
         const updatedProfile = {
             ...actorSession.profile,
             allowedSubjectDids: authorizedSubjectDids,
@@ -651,18 +669,19 @@ export class ServerProfileSessionManager {
         const stored = await this.options.store.getSession(input.sessionId);
         if (!stored || stored.ownerId !== input.ownerId)
             throw new Error('Profile session not found.');
-        const subjectDid = String(input.subjectDid || '').trim();
-        if (!subjectDid || !(stored.authorizedSubjectDids || []).includes(subjectDid)) {
+        const requestedSubjectDid = String(input.subjectDid || '').trim();
+        if (!requestedSubjectDid || !(stored.authorizedSubjectDids || []).includes(requestedSubjectDid)) {
             throw new Error('Subject is not authorized for this personal actor profile.');
         }
-        const selectedGrant = stored.authorizedSubjects?.find((grant) => grant.subjectDid === subjectDid);
+        const selectedGrant = stored.authorizedSubjects?.find((grant) => grant.subjectDid === requestedSubjectDid);
         if (!selectedGrant) {
             throw new Error('Subject relationship metadata is missing from this personal actor session.');
         }
         const idToken = String(input.idToken || '').trim();
         if (!idToken)
             throw new Error('Subject selection requires idToken.');
-        const scopes = unique(input.scopes);
+        const subjectDid = String(selectedGrant.transportSubjectDid || requestedSubjectDid).trim();
+        const scopes = unique(input.scopes).map((scope) => rewriteSmartScopeSubject(scope, requestedSubjectDid, subjectDid));
         if (!scopes.length)
             throw new Error('Subject selection requires scopes.');
         const walletState = await this.resolveWalletState(input.ownerId, input.sessionId);
@@ -1151,6 +1170,30 @@ export class ServerProfileSessionManager {
     }
     now() { return this.options.now?.() || new Date(); }
 }
+/** Resolves the private individual DID rooted in one registered controller actor. */
+function canonicalIndividualControllerSubject(profile) {
+    if (profile.actorKind !== ActorKinds.IndividualController)
+        return undefined;
+    try {
+        return parseIndividualMemberDidWeb(profile.actorDid).individualDidWeb;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Rebinds a selected public card alias to its canonical SMART subject. */
+function rewriteSmartScopeSubject(scope, requestedSubjectDid, transportSubjectDid) {
+    const value = String(scope || '').trim();
+    if (!value || requestedSubjectDid === transportSubjectDid)
+        return value;
+    const [permission, query = ''] = value.split('?', 2);
+    const parameters = new URLSearchParams(query);
+    if (parameters.get('subject') !== requestedSubjectDid) {
+        throw new Error('Every SMART scope must be bound to the selected public subject alias.');
+    }
+    parameters.set('subject', transportSubjectDid);
+    return `${permission}?${parameters.toString()}`;
+}
 /**
  * Binds every direct resource action and async poll to the actor and DCR client
  * stored in the server profile. The caller may author the business body and

package/dist/terminology-service-client.d.ts

@@ -0,0 +1,98 @@
+/** Input resolved by an authenticated application BFF, never directly by a browser. */
+export type TerminologyValueSetInput = Readonly<{
+    /** Optional per-request override. Dedicated BFFs normally configure this once on the client. */
+    sector?: string;
+    claim: string;
+    fhirVersion?: 'R4';
+    language?: string;
+    jurisdiction?: string;
+    /** Exact code-system version URI. Omission asks the service for its latest/default release. */
+    version?: string;
+    offset?: number;
+    count?: number;
+}>;
+export type TerminologyValueSetCodeListInput = Omit<TerminologyValueSetInput, 'offset' | 'count'>;
+export type TerminologyValueSetOption = Readonly<{
+    system: string;
+    code: string;
+    display: string;
+    localizedDisplay: string;
+    resolvedLanguage: string;
+    fallbackUsed: boolean;
+}>;
+export type TerminologyValueSetDocument = Readonly<{
+    jsonapi: Readonly<{
+        version: '1.1';
+    }>;
+    data: readonly Readonly<{
+        type: 'terminology-option';
+        id: string;
+        attributes: TerminologyValueSetOption;
+    }>[];
+    meta: Readonly<{
+        count: number;
+        total: number;
+        offset: number;
+        language: string;
+        resourceType: string;
+        field: string;
+        claim: string;
+        valueSet: Readonly<{
+            id: string;
+            url: string;
+            version: string;
+            system: string;
+        }>;
+        terminologyVersions?: Readonly<Record<string, string>>;
+    }>;
+}>;
+export type TerminologyCacheEntry = Readonly<{
+    document: TerminologyValueSetDocument;
+    storedAt: number;
+}>;
+export interface TerminologyValueSetCache {
+    get(key: string): TerminologyCacheEntry | undefined | Promise<TerminologyCacheEntry | undefined>;
+    set(key: string, entry: TerminologyCacheEntry): void | Promise<void>;
+}
+/** Stable key usable by in-memory, GCS, Firestore or PostgreSQL cache adapters. */
+export declare function terminologyValueSetCacheKey(input: TerminologyValueSetInput): string;
+/** Process-local cache suitable for warm BFF instances and immutable startup snapshots. */
+export declare class MemoryTerminologyValueSetCache implements TerminologyValueSetCache {
+    #private;
+    get(key: string): TerminologyCacheEntry | undefined;
+    set(key: string, entry: TerminologyCacheEntry): void;
+    prime(input: TerminologyValueSetInput, document: TerminologyValueSetDocument, storedAt?: number): void;
+}
+export type TerminologyValueSetResult = Readonly<{
+    document: TerminologyValueSetDocument;
+    cacheStatus: 'remote' | 'fresh-cache' | 'stale-cache' | 'english-fallback-cache';
+}>;
+/** Frontend-ready code list. Coding system and code remain separate FHIR Coding values. */
+export type TerminologyValueSetCodeList = Readonly<{
+    codingSystem: string;
+    codeToDisplay: Readonly<Record<string, string>>;
+    requestedLanguage: string;
+    resolvedLanguage: string;
+    fallbackUsed: boolean;
+    valueSet: TerminologyValueSetDocument['meta']['valueSet'];
+    terminologyVersions?: Readonly<Record<string, string>>;
+}>;
+/** Server-only client for a product-neutral terminology service. */
+export declare class TerminologyServiceClient {
+    #private;
+    constructor(options: Readonly<{
+        baseUrl: string;
+        /** Default sector for a dedicated human-health or animal-health BFF. */
+        sector?: string;
+        serviceToken?: string;
+        fetchImplementation?: typeof fetch;
+        cache?: TerminologyValueSetCache;
+        cacheTtlMs?: number;
+        staleIfError?: boolean;
+        now?: () => number;
+    }>);
+    /** Resolves the ValueSet bound by the service to one canonical flat claim. */
+    expandValueSetForClaim(input: TerminologyValueSetInput): Promise<TerminologyValueSetResult>;
+    /** Resolves every page and returns the simple code-to-display object expected by forms. */
+    getValueSetCodeListForClaim(input: TerminologyValueSetCodeListInput): Promise<TerminologyValueSetCodeList>;
+}

package/dist/terminology-service-client.js

@@ -0,0 +1,225 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _MemoryTerminologyValueSetCache_entries, _TerminologyServiceClient_instances, _TerminologyServiceClient_baseUrl, _TerminologyServiceClient_serviceToken, _TerminologyServiceClient_sector, _TerminologyServiceClient_fetch, _TerminologyServiceClient_cache, _TerminologyServiceClient_cacheTtlMs, _TerminologyServiceClient_staleIfError, _TerminologyServiceClient_now, _TerminologyServiceClient_request, _TerminologyServiceClient_validateInput, _TerminologyServiceClient_isDocument;
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+function normalizedInput(input) {
+    return {
+        claim: input.claim.trim(),
+        fhirVersion: input.fhirVersion ?? 'R4',
+        language: (input.language?.trim() || 'en').replace(/_/g, '-').toLowerCase(),
+        ...(input.jurisdiction?.trim() ? { jurisdiction: input.jurisdiction.trim().toUpperCase() } : {}),
+        ...(input.version?.trim() ? { version: input.version.trim() } : {}),
+        offset: input.offset ?? 0,
+        count: input.count ?? 50,
+    };
+}
+/** Stable key usable by in-memory, GCS, Firestore or PostgreSQL cache adapters. */
+export function terminologyValueSetCacheKey(input) {
+    const normalizedTerminologyContext = normalizedInput(input);
+    return JSON.stringify([
+        normalizedTerminologyContext.fhirVersion,
+        input.sector?.trim().toLowerCase() ?? '',
+        normalizedTerminologyContext.claim,
+        normalizedTerminologyContext.language,
+        normalizedTerminologyContext.jurisdiction ?? '',
+        normalizedTerminologyContext.version ?? 'latest',
+        normalizedTerminologyContext.offset,
+        normalizedTerminologyContext.count,
+    ]);
+}
+function resourceTypeFromClaim(claim) {
+    const canonicalClaim = claim.trim();
+    const separatorIndex = canonicalClaim.indexOf('.');
+    const resourceType = canonicalClaim.slice(0, separatorIndex);
+    if (separatorIndex < 1 || !/^[A-Z][A-Za-z0-9]*$/.test(resourceType)) {
+        throw new Error('claim must start with its FHIR resource type');
+    }
+    return resourceType;
+}
+/** Process-local cache suitable for warm BFF instances and immutable startup snapshots. */
+export class MemoryTerminologyValueSetCache {
+    constructor() {
+        _MemoryTerminologyValueSetCache_entries.set(this, new Map());
+    }
+    get(key) {
+        return __classPrivateFieldGet(this, _MemoryTerminologyValueSetCache_entries, "f").get(key);
+    }
+    set(key, entry) {
+        __classPrivateFieldGet(this, _MemoryTerminologyValueSetCache_entries, "f").set(key, entry);
+    }
+    prime(input, document, storedAt = Date.now()) {
+        this.set(terminologyValueSetCacheKey(input), { document, storedAt });
+    }
+}
+_MemoryTerminologyValueSetCache_entries = new WeakMap();
+/** Server-only client for a product-neutral terminology service. */
+export class TerminologyServiceClient {
+    constructor(options) {
+        _TerminologyServiceClient_instances.add(this);
+        _TerminologyServiceClient_baseUrl.set(this, void 0);
+        _TerminologyServiceClient_serviceToken.set(this, void 0);
+        _TerminologyServiceClient_sector.set(this, void 0);
+        _TerminologyServiceClient_fetch.set(this, void 0);
+        _TerminologyServiceClient_cache.set(this, void 0);
+        _TerminologyServiceClient_cacheTtlMs.set(this, void 0);
+        _TerminologyServiceClient_staleIfError.set(this, void 0);
+        _TerminologyServiceClient_now.set(this, void 0);
+        __classPrivateFieldSet(this, _TerminologyServiceClient_baseUrl, options.baseUrl.replace(/\/$/, ''), "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_serviceToken, options.serviceToken?.trim() || undefined, "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_sector, options.sector?.trim() || undefined, "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_fetch, options.fetchImplementation ?? fetch, "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_cache, options.cache ?? new MemoryTerminologyValueSetCache(), "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_cacheTtlMs, options.cacheTtlMs ?? DEFAULT_TTL_MS, "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_staleIfError, options.staleIfError ?? true, "f");
+        __classPrivateFieldSet(this, _TerminologyServiceClient_now, options.now ?? Date.now, "f");
+    }
+    /** Resolves the ValueSet bound by the service to one canonical flat claim. */
+    async expandValueSetForClaim(input) {
+        __classPrivateFieldGet(this, _TerminologyServiceClient_instances, "m", _TerminologyServiceClient_validateInput).call(this, input);
+        const resolvedTerminologyContext = {
+            ...input,
+            sector: input.sector?.trim() || __classPrivateFieldGet(this, _TerminologyServiceClient_sector, "f"),
+        };
+        const key = terminologyValueSetCacheKey(resolvedTerminologyContext);
+        const cached = await __classPrivateFieldGet(this, _TerminologyServiceClient_cache, "f").get(key);
+        if (cached && __classPrivateFieldGet(this, _TerminologyServiceClient_now, "f").call(this) - cached.storedAt <= __classPrivateFieldGet(this, _TerminologyServiceClient_cacheTtlMs, "f")) {
+            return { document: cached.document, cacheStatus: 'fresh-cache' };
+        }
+        try {
+            const document = await __classPrivateFieldGet(this, _TerminologyServiceClient_instances, "m", _TerminologyServiceClient_request).call(this, resolvedTerminologyContext);
+            await __classPrivateFieldGet(this, _TerminologyServiceClient_cache, "f").set(key, { document, storedAt: __classPrivateFieldGet(this, _TerminologyServiceClient_now, "f").call(this) });
+            return { document, cacheStatus: 'remote' };
+        }
+        catch (error) {
+            if (cached && __classPrivateFieldGet(this, _TerminologyServiceClient_staleIfError, "f")) {
+                return { document: cached.document, cacheStatus: 'stale-cache' };
+            }
+            const requestedLanguage = input.language?.trim().toLowerCase();
+            if (__classPrivateFieldGet(this, _TerminologyServiceClient_staleIfError, "f") && requestedLanguage && requestedLanguage !== 'en') {
+                const english = await __classPrivateFieldGet(this, _TerminologyServiceClient_cache, "f").get(terminologyValueSetCacheKey({
+                    ...resolvedTerminologyContext,
+                    language: 'en',
+                }));
+                if (english) {
+                    return { document: english.document, cacheStatus: 'english-fallback-cache' };
+                }
+            }
+            throw new Error('Terminology service request failed');
+        }
+    }
+    /** Resolves every page and returns the simple code-to-display object expected by forms. */
+    async getValueSetCodeListForClaim(input) {
+        const pageSize = 100;
+        let nextOffset = 0;
+        let totalOptionCount = 0;
+        let codingSystem = '';
+        let resolvedLanguage = '';
+        let fallbackUsed = false;
+        let resolvedValueSet;
+        let terminologyVersions;
+        const codeToDisplay = {};
+        do {
+            const valueSetPage = await this.expandValueSetForClaim({
+                ...input,
+                offset: nextOffset,
+                count: pageSize,
+            });
+            const { document } = valueSetPage;
+            totalOptionCount = document.meta.total;
+            resolvedLanguage || (resolvedLanguage = document.meta.language);
+            resolvedValueSet ?? (resolvedValueSet = document.meta.valueSet);
+            terminologyVersions ?? (terminologyVersions = document.meta.terminologyVersions);
+            if (resolvedValueSet.system !== document.meta.valueSet.system) {
+                throw new Error('Terminology service returned inconsistent ValueSet pages');
+            }
+            for (const terminologyOptionResource of document.data) {
+                const terminologyOption = terminologyOptionResource.attributes;
+                if (codingSystem && codingSystem !== terminologyOption.system) {
+                    throw new Error('Terminology ValueSet contains more than one coding system');
+                }
+                codingSystem || (codingSystem = terminologyOption.system);
+                codeToDisplay[terminologyOption.code] = terminologyOption.localizedDisplay;
+                fallbackUsed || (fallbackUsed = terminologyOption.fallbackUsed);
+            }
+            if (document.data.length === 0 && nextOffset < totalOptionCount) {
+                throw new Error('Terminology service returned an incomplete ValueSet page');
+            }
+            nextOffset += document.data.length;
+        } while (nextOffset < totalOptionCount);
+        if (!resolvedValueSet)
+            throw new Error('Terminology service returned no ValueSet metadata');
+        return {
+            codingSystem: codingSystem || resolvedValueSet.system,
+            codeToDisplay,
+            requestedLanguage: (input.language?.trim() || 'en').replace(/_/g, '-').toLowerCase(),
+            resolvedLanguage: resolvedLanguage || 'en',
+            fallbackUsed,
+            valueSet: resolvedValueSet,
+            ...(terminologyVersions ? { terminologyVersions } : {}),
+        };
+    }
+}
+_TerminologyServiceClient_baseUrl = new WeakMap(), _TerminologyServiceClient_serviceToken = new WeakMap(), _TerminologyServiceClient_sector = new WeakMap(), _TerminologyServiceClient_fetch = new WeakMap(), _TerminologyServiceClient_cache = new WeakMap(), _TerminologyServiceClient_cacheTtlMs = new WeakMap(), _TerminologyServiceClient_staleIfError = new WeakMap(), _TerminologyServiceClient_now = new WeakMap(), _TerminologyServiceClient_instances = new WeakSet(), _TerminologyServiceClient_request = async function _TerminologyServiceClient_request(input) {
+    const url = new URL(`${__classPrivateFieldGet(this, _TerminologyServiceClient_baseUrl, "f")}/v1/terminology/value-set-options`);
+    url.searchParams.set('sector', input.sector?.trim() || __classPrivateFieldGet(this, _TerminologyServiceClient_sector, "f") || '');
+    url.searchParams.set('claim', input.claim.trim());
+    url.searchParams.set('offset', String(input.offset ?? 0));
+    url.searchParams.set('count', String(input.count ?? 50));
+    if (input.fhirVersion)
+        url.searchParams.set('fhirVersion', input.fhirVersion);
+    if (input.language?.trim())
+        url.searchParams.set('language', input.language.trim());
+    if (input.jurisdiction?.trim())
+        url.searchParams.set('jurisdiction', input.jurisdiction.trim());
+    if (input.version?.trim())
+        url.searchParams.set('version', input.version.trim());
+    const response = await __classPrivateFieldGet(this, _TerminologyServiceClient_fetch, "f").call(this, url, {
+        headers: {
+            accept: 'application/vnd.api+json',
+            ...(__classPrivateFieldGet(this, _TerminologyServiceClient_serviceToken, "f") ? { authorization: `Bearer ${__classPrivateFieldGet(this, _TerminologyServiceClient_serviceToken, "f")}` } : {}),
+        },
+    });
+    if (!response.ok)
+        throw new Error(`Terminology service returned HTTP ${response.status}`);
+    const document = await response.json();
+    if (!__classPrivateFieldGet(this, _TerminologyServiceClient_instances, "m", _TerminologyServiceClient_isDocument).call(this, document, input))
+        throw new Error('Terminology service returned an invalid document');
+    return document;
+}, _TerminologyServiceClient_validateInput = function _TerminologyServiceClient_validateInput(input) {
+    if (!(input.sector?.trim() || __classPrivateFieldGet(this, _TerminologyServiceClient_sector, "f")))
+        throw new Error('sector is required');
+    if (!input.claim.trim())
+        throw new Error('claim is required');
+    resourceTypeFromClaim(input.claim);
+    if (input.offset !== undefined && (!Number.isInteger(input.offset) || input.offset < 0)) {
+        throw new Error('offset must be a non-negative integer');
+    }
+    if (input.count !== undefined && (!Number.isInteger(input.count) || input.count < 1 || input.count > 100)) {
+        throw new Error('count must be an integer from 1 to 100');
+    }
+}, _TerminologyServiceClient_isDocument = function _TerminologyServiceClient_isDocument(value, input) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const document = value;
+    if (document.jsonapi?.version !== '1.1' || !Array.isArray(document.data) || !document.meta)
+        return false;
+    if (document.meta.resourceType !== resourceTypeFromClaim(input.claim) || document.meta.claim !== input.claim.trim())
+        return false;
+    return document.data.every((resource) => (resource?.type === 'terminology-option'
+        && typeof resource.id === 'string'
+        && typeof resource.attributes?.system === 'string'
+        && typeof resource.attributes?.code === 'string'
+        && typeof resource.attributes?.display === 'string'
+        && typeof resource.attributes?.localizedDisplay === 'string'
+        && typeof resource.attributes?.resolvedLanguage === 'string'
+        && typeof resource.attributes?.fallbackUsed === 'boolean'));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "2.9.19",
+  "version": "2.9.21",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -38,7 +38,7 @@
     "test:e2e:live-gw:clean": "bash ./scripts/run-live-gw-clean.sh"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "2.9.18",
+    "gdc-common-utils-ts": "2.9.20",
     "gdc-sdk-core-ts": "2.9.10"
   },
   "devDependencies": {