gdc-common-utils-ts 1.20.0 → 1.20.2

package/dist/constants/schemaorg.d.ts

@@ -109,6 +109,20 @@ export declare enum ClaimsOfferSchemaorg {
     priceCurrency = "org.schema.Offer.priceCurrency",
     serialNumber = "org.schema.Offer.serialNumber"
 }
+/**
+ * Canonical claim names used by the current GDC profile when a VC or flat
+ * request models a `schema.org/IndividualProduct`.
+ *
+ * Current GW licensing semantics use this family to represent:
+ * - the concrete seat/license serial number
+ * - the license category (`professional` or `individual`)
+ * - the target app/device form factor (`mobile` or `web`)
+ */
+export declare enum ClaimsIndividualProductSchemaorg {
+    category = "org.schema.IndividualProduct.category",
+    additionalType = "org.schema.IndividualProduct.additionalType",
+    serialNumber = "org.schema.IndividualProduct.serialNumber"
+}
 export declare enum ClaimsOrderSchemaorg {
     orderedItemServiceType = "org.schema.Order.orderedItem.serviceType"
 }

package/dist/constants/schemaorg.js

@@ -114,6 +114,21 @@ export var ClaimsOfferSchemaorg;
     ClaimsOfferSchemaorg["priceCurrency"] = "org.schema.Offer.priceCurrency";
     ClaimsOfferSchemaorg["serialNumber"] = "org.schema.Offer.serialNumber";
 })(ClaimsOfferSchemaorg || (ClaimsOfferSchemaorg = {}));
+/**
+ * Canonical claim names used by the current GDC profile when a VC or flat
+ * request models a `schema.org/IndividualProduct`.
+ *
+ * Current GW licensing semantics use this family to represent:
+ * - the concrete seat/license serial number
+ * - the license category (`professional` or `individual`)
+ * - the target app/device form factor (`mobile` or `web`)
+ */
+export var ClaimsIndividualProductSchemaorg;
+(function (ClaimsIndividualProductSchemaorg) {
+    ClaimsIndividualProductSchemaorg["category"] = "org.schema.IndividualProduct.category";
+    ClaimsIndividualProductSchemaorg["additionalType"] = "org.schema.IndividualProduct.additionalType";
+    ClaimsIndividualProductSchemaorg["serialNumber"] = "org.schema.IndividualProduct.serialNumber";
+})(ClaimsIndividualProductSchemaorg || (ClaimsIndividualProductSchemaorg = {}));
 export var ClaimsOrderSchemaorg;
 (function (ClaimsOrderSchemaorg) {
     ClaimsOrderSchemaorg["orderedItemServiceType"] = "org.schema.Order.orderedItem.serviceType";

package/dist/constants/service-capabilities.d.ts

@@ -88,6 +88,10 @@ export type ServiceCapabilityTokenValue = typeof ServiceCapabilityToken[keyof ty
  * Normalizes a service capability token into its canonical persisted form.
  */
 export declare function normalizeServiceCapability(value: string | undefined | null): string | undefined;
+/**
+ * Returns whether the token is one of the known persisted service capabilities.
+ */
+export declare function isKnownServiceCapability(value: string | undefined | null): boolean;
 /**
  * Parses the CSV stored in `org.schema.Service.serviceType`.
  */

package/dist/constants/service-capabilities.js

@@ -108,6 +108,15 @@ export function normalizeServiceCapability(value) {
         return undefined;
     return CANONICAL_SERVICE_CAPABILITY_BY_VALUE.get(normalized.toLowerCase()) || normalized;
 }
+/**
+ * Returns whether the token is one of the known persisted service capabilities.
+ */
+export function isKnownServiceCapability(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (!normalized)
+        return false;
+    return CANONICAL_SERVICE_CAPABILITY_BY_VALUE.has(normalized);
+}
 /**
  * Parses the CSV stored in `org.schema.Service.serviceType`.
  */

package/dist/examples/index.d.ts

@@ -5,6 +5,7 @@ export * from './organization-controller';
 export * from './individual-controller';
 export * from './professional';
 export * from './employee';
+export * from './license';
 export * from './related-person';
 export * from './consent-access';
 export * from './relationship-access';

package/dist/examples/index.js

@@ -5,6 +5,7 @@ export * from './organization-controller.js';
 export * from './individual-controller.js';
 export * from './professional.js';
 export * from './employee.js';
+export * from './license.js';
 export * from './related-person.js';
 export * from './consent-access.js';
 export * from './relationship-access.js';

package/dist/examples/license.d.ts

@@ -0,0 +1,32 @@
+export declare const EXAMPLE_LICENSE_SEAT_UUIDS: readonly ["8a8a5e1b-0d8e-4a7c-8c39-3b8034440001", "8a8a5e1b-0d8e-4a7c-8c39-3b8034440002"];
+export declare const EXAMPLE_LICENSE_ISSUE_INPUT: Readonly<{
+    readonly email: "controller@acme.org";
+    readonly role: "ISCO-08|2211";
+    readonly userClass: "employee";
+    readonly type: "mobile";
+}>;
+export declare const EXAMPLE_LICENSE_PURCHASE_INPUT: Readonly<{
+    readonly quantity: 2;
+    readonly userClass: "employee";
+    readonly type: "web";
+    readonly serialNumbers: readonly ["8a8a5e1b-0d8e-4a7c-8c39-3b8034440001", "8a8a5e1b-0d8e-4a7c-8c39-3b8034440002"];
+}>;
+export declare const EXAMPLE_LICENSE_ACTIVE_RECORD: Readonly<{
+    readonly id: "8a8a5e1b-0d8e-4a7c-8c39-3b8034440001";
+    readonly status: "active";
+    readonly activationCode: "ACT-001";
+    readonly subjectId: "urn:uuid:employee-controller-active-001";
+    readonly claims: {
+        readonly '@context': "org.schema";
+        readonly "org.schema.IndividualProduct.serialNumber": "8a8a5e1b-0d8e-4a7c-8c39-3b8034440001";
+        readonly "org.schema.IndividualProduct.category": "professional";
+        readonly "org.schema.IndividualProduct.additionalType": "mobile";
+        readonly "org.schema.Person.email": "controller@acme.org";
+        readonly "org.schema.Person.hasOccupation.identifier.value": "ISCO-08|2211";
+    };
+}>;
+export declare function buildExampleLicenseIssueClaims(): Readonly<Record<string, unknown>>;
+export declare function buildExampleLicensePurchaseClaims(): Readonly<Record<string, unknown>>;
+export declare const EXAMPLE_LICENSE_PURCHASE_CLAIMS: Readonly<Record<string, unknown>>;
+export declare const EXAMPLE_LICENSE_ISSUE_CLAIMS: Readonly<Record<string, unknown>>;
+export declare const EXAMPLE_LICENSE_PURCHASE_EXPECTED_SERIAL_NUMBER: string;

package/dist/examples/license.js

@@ -0,0 +1,43 @@
+import { DeviceAppTypes, DeviceUserClasses } from '../constants/device.js';
+import { ClaimsIndividualProductSchemaorg, ClaimsOfferSchemaorg, ClaimsPersonSchemaorg, } from '../constants/schemaorg.js';
+import { buildLicenseIssueClaims, buildLicensePurchaseClaims, LicenseCategories, LicenseStatuses, } from '../utils/license.js';
+import { EXAMPLE_EMAIL_CONTROLLER_ORG, EXAMPLE_EMPLOYEE_ACTIVATION_CODE, EXAMPLE_HEALTHCARE_ACTOR_ROLE_GENERALIST_MEDICAL_PRACTITIONER, } from './shared.js';
+export const EXAMPLE_LICENSE_SEAT_UUIDS = Object.freeze([
+    '8a8a5e1b-0d8e-4a7c-8c39-3b8034440001',
+    '8a8a5e1b-0d8e-4a7c-8c39-3b8034440002',
+]);
+export const EXAMPLE_LICENSE_ISSUE_INPUT = Object.freeze({
+    email: EXAMPLE_EMAIL_CONTROLLER_ORG,
+    role: EXAMPLE_HEALTHCARE_ACTOR_ROLE_GENERALIST_MEDICAL_PRACTITIONER,
+    userClass: DeviceUserClasses.Employee,
+    type: DeviceAppTypes.Mobile,
+});
+export const EXAMPLE_LICENSE_PURCHASE_INPUT = Object.freeze({
+    quantity: EXAMPLE_LICENSE_SEAT_UUIDS.length,
+    userClass: DeviceUserClasses.Employee,
+    type: DeviceAppTypes.Web,
+    serialNumbers: EXAMPLE_LICENSE_SEAT_UUIDS,
+});
+export const EXAMPLE_LICENSE_ACTIVE_RECORD = Object.freeze({
+    id: EXAMPLE_LICENSE_SEAT_UUIDS[0],
+    status: LicenseStatuses.Active,
+    activationCode: EXAMPLE_EMPLOYEE_ACTIVATION_CODE,
+    subjectId: 'urn:uuid:employee-controller-active-001',
+    claims: {
+        '@context': 'org.schema',
+        [ClaimsIndividualProductSchemaorg.serialNumber]: EXAMPLE_LICENSE_SEAT_UUIDS[0],
+        [ClaimsIndividualProductSchemaorg.category]: LicenseCategories.Professional,
+        [ClaimsIndividualProductSchemaorg.additionalType]: DeviceAppTypes.Mobile,
+        [ClaimsPersonSchemaorg.email]: EXAMPLE_EMAIL_CONTROLLER_ORG,
+        [ClaimsPersonSchemaorg.hasOccupationalRoleValue]: EXAMPLE_HEALTHCARE_ACTOR_ROLE_GENERALIST_MEDICAL_PRACTITIONER,
+    },
+});
+export function buildExampleLicenseIssueClaims() {
+    return Object.freeze(buildLicenseIssueClaims(EXAMPLE_LICENSE_ISSUE_INPUT));
+}
+export function buildExampleLicensePurchaseClaims() {
+    return Object.freeze(buildLicensePurchaseClaims(EXAMPLE_LICENSE_PURCHASE_INPUT));
+}
+export const EXAMPLE_LICENSE_PURCHASE_CLAIMS = buildExampleLicensePurchaseClaims();
+export const EXAMPLE_LICENSE_ISSUE_CLAIMS = buildExampleLicenseIssueClaims();
+export const EXAMPLE_LICENSE_PURCHASE_EXPECTED_SERIAL_NUMBER = EXAMPLE_LICENSE_PURCHASE_CLAIMS[ClaimsOfferSchemaorg.serialNumber];

package/dist/utils/dataspace-discovery.js

@@ -1,7 +1,7 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
 import { ClaimsOrganizationSchemaorg, ClaimsServiceSchemaorg } from '../constants/schemaorg.js';
 import { isEuCountryCode, normalizeCountryCode } from '../constants/eu-countries.js';
-import { isProviderServiceCapability, parseServiceCapabilityTokens, } from '../constants/service-capabilities.js';
+import { isKnownServiceCapability, isProviderServiceCapability, parseServiceCapabilityTokens, } from '../constants/service-capabilities.js';
 import { DataspaceCoverageScope, } from '../models/dataspace-discovery.js';
 function asObject(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
@@ -142,13 +142,20 @@ export function parseServiceTypeCsv(value) {
     }
     return parseServiceCapabilityTokens(value);
 }
+function parseAdditionalTypeCapabilityCsv(value) {
+    if (Array.isArray(value)) {
+        return Array.from(new Set(value.flatMap((entry) => parseAdditionalTypeCapabilityCsv(entry))));
+    }
+    return parseServiceCapabilityTokens(value)
+        .filter((item) => isKnownServiceCapability(item));
+}
 /**
  * Parses service capability tokens from both `serviceType` and `additionalType`.
  */
 export function parseServiceTypeClaims(serviceTypeValue, additionalTypeValue) {
     return Array.from(new Set([
         ...parseServiceTypeCsv(serviceTypeValue),
-        ...parseServiceTypeCsv(additionalTypeValue),
+        ...parseAdditionalTypeCapabilityCsv(additionalTypeValue),
     ]));
 }
 /**

package/dist/utils/index.d.ts

@@ -43,6 +43,7 @@ export * from './individual-onboarding-document-reference';
 export * from './individual-organization-kyc';
 export * from './ips-bundle-claims';
 export * from './jwt';
+export * from './license';
 export * from './manager-error';
 export * from './multibase58';
 export * from './multibasehash';
@@ -52,5 +53,6 @@ export * from './object-convert';
 export * from './normalize-uuid';
 export * from './permission-templates';
 export * from './smart-scope';
+export * from './service-act-reasons';
 export * from './activation-request';
 export * from './vp-token';

package/dist/utils/index.js

@@ -43,6 +43,7 @@ export * from './individual-onboarding-document-reference.js';
 export * from './individual-organization-kyc.js';
 export * from './ips-bundle-claims.js';
 export * from './jwt.js';
+export * from './license.js';
 export * from './manager-error.js';
 export * from './multibase58.js';
 export * from './multibasehash.js';
@@ -52,5 +53,6 @@ export * from './object-convert.js';
 export * from './normalize-uuid.js';
 export * from './permission-templates.js';
 export * from './smart-scope.js';
+export * from './service-act-reasons.js';
 export * from './activation-request.js';
 export * from './vp-token.js';

package/dist/utils/license.d.ts

@@ -0,0 +1,149 @@
+import { DeviceAppType, DeviceUserClass } from '../constants/device';
+export type LicenseClaims = Record<string, unknown>;
+export declare const LicenseClaimContext: Readonly<{
+    readonly SchemaOrg: "org.schema";
+}>;
+/**
+ * Canonical business categories currently used by GW licensing flows.
+ *
+ * Mapping:
+ * - employee -> professional
+ * - individual -> individual
+ */
+export declare const LicenseCategories: Readonly<{
+    readonly Professional: "professional";
+    readonly Individual: "individual";
+}>;
+export type LicenseCategory = typeof LicenseCategories[keyof typeof LicenseCategories];
+/**
+ * Stable helper-level request type ids for license-oriented batch entries.
+ *
+ * These are request metadata strings emitted by SDK/common-utils helpers so
+ * callers do not handcraft type labels inline.
+ */
+export declare const LicenseEntryTypes: Readonly<{
+    readonly Issue: "License-issue-request-v1.0";
+    readonly Purchase: "License-purchase-request-v1.0";
+    readonly Search: "License-search-request-v1.0";
+}>;
+export declare const LicenseEntryOperations: Readonly<{
+    readonly Issue: "IndividualProduct:Issue";
+    readonly Purchase: "IndividualProduct:Purchase";
+    readonly Search: "IndividualProduct:Search";
+}>;
+export declare const LicenseRequestMethods: Readonly<{
+    readonly Post: "POST";
+}>;
+/**
+ * Runtime-facing lifecycle values commonly used when searching stored
+ * `DeviceLicense` documents.
+ *
+ * These are not schema.org claims. They are operational filters that runtime
+ * layers may attach alongside the canonical schema.org claims.
+ */
+export declare const LicenseStatuses: Readonly<{
+    readonly Available: "available";
+    readonly Issued: "issued";
+    readonly Active: "active";
+    readonly Inactive: "inactive";
+}>;
+export type LicenseStatus = typeof LicenseStatuses[keyof typeof LicenseStatuses];
+export type LicenseIssueInput = Readonly<{
+    email: string;
+    role: string;
+    userClass?: DeviceUserClass;
+    type?: DeviceAppType;
+    additionalClaims?: LicenseClaims;
+}>;
+export type LicensePurchaseInput = Readonly<{
+    quantity: number;
+    userClass?: DeviceUserClass;
+    type?: DeviceAppType;
+    serialNumbers?: readonly string[];
+    additionalClaims?: LicenseClaims;
+}>;
+export type LicenseSearchInput = Readonly<{
+    serialNumbers?: readonly string[];
+    userClass?: DeviceUserClass;
+    type?: DeviceAppType;
+    email?: string;
+    role?: string;
+    status?: LicenseStatus;
+    subjectId?: string;
+    additionalClaims?: LicenseClaims;
+}>;
+/**
+ * Maps one canonical runtime user class to the schema.org-compatible
+ * `IndividualProduct.category` value used by current GW flows.
+ */
+export declare function mapLicenseCategoryFromUserClass(userClass?: DeviceUserClass): LicenseCategory;
+/**
+ * Converts a list of seat ids / serial numbers into the compact string form
+ * currently stored in `org.schema.Offer.serialNumber`.
+ */
+export declare function serializeLicenseSerialNumbers(serialNumbers?: readonly string[]): string | undefined;
+/**
+ * Builds canonical `org.schema.*` claims for `License/_issue`.
+ *
+ * The resulting payload keeps current GW semantics:
+ * - recipient identity/role comes from `Person.*`
+ * - seat/app semantics come from `IndividualProduct.*`
+ */
+export declare function buildLicenseIssueClaims(input: LicenseIssueInput): LicenseClaims;
+/**
+ * Builds the canonical batch entry for `License/_issue`.
+ */
+export declare function buildLicenseIssueEntry(input: LicenseIssueInput): {
+    type: string;
+    request: {
+        method: 'POST';
+    };
+    meta: {
+        claims: LicenseClaims;
+    };
+};
+/**
+ * Builds canonical schema.org claims for a license purchase / seat-creation
+ * request.
+ *
+ * Current business semantics:
+ * - `Offer.eligibleQuantity.value` requests how many seats must exist
+ * - `Offer.serialNumber` can optionally carry the explicit seat ids when they
+ *   are already known or preallocated
+ * - `IndividualProduct.*` classifies the target seat family/form factor
+ */
+export declare function buildLicensePurchaseClaims(input: LicensePurchaseInput): LicenseClaims;
+/**
+ * Builds the canonical batch entry for a purchase/order-oriented license
+ * request.
+ */
+export declare function buildLicensePurchaseEntry(input: LicensePurchaseInput): {
+    type: string;
+    request: {
+        method: 'POST';
+    };
+    meta: {
+        claims: LicenseClaims;
+    };
+};
+/**
+ * Builds the canonical search envelope for license listing.
+ *
+ * Split of concerns:
+ * - schema.org-compatible selectors stay in `meta.claims`
+ * - document lifecycle stays in `meta.status`, mirroring the current
+ *   `ConfidentialStorageDoc.status` usage
+ * - `subjectId` remains an explicit side-field until a canonical indexed claim
+ *   is introduced for that lookup
+ */
+export declare function buildLicenseSearchEntry(input: LicenseSearchInput): {
+    type: string;
+    request: {
+        method: 'POST';
+    };
+    meta: {
+        claims: LicenseClaims;
+        status?: LicenseStatus;
+        subjectId?: string;
+    };
+};

package/dist/utils/license.js

@@ -0,0 +1,188 @@
+import { DeviceAppTypes, DeviceUserClasses } from '../constants/device.js';
+import { ClaimsIndividualProductSchemaorg, ClaimsOfferSchemaorg, ClaimsPersonSchemaorg, } from '../constants/schemaorg.js';
+export const LicenseClaimContext = Object.freeze({
+    SchemaOrg: 'org.schema',
+});
+/**
+ * Canonical business categories currently used by GW licensing flows.
+ *
+ * Mapping:
+ * - employee -> professional
+ * - individual -> individual
+ */
+export const LicenseCategories = Object.freeze({
+    Professional: 'professional',
+    Individual: 'individual',
+});
+/**
+ * Stable helper-level request type ids for license-oriented batch entries.
+ *
+ * These are request metadata strings emitted by SDK/common-utils helpers so
+ * callers do not handcraft type labels inline.
+ */
+export const LicenseEntryTypes = Object.freeze({
+    Issue: 'License-issue-request-v1.0',
+    Purchase: 'License-purchase-request-v1.0',
+    Search: 'License-search-request-v1.0',
+});
+export const LicenseEntryOperations = Object.freeze({
+    Issue: 'IndividualProduct:Issue',
+    Purchase: 'IndividualProduct:Purchase',
+    Search: 'IndividualProduct:Search',
+});
+export const LicenseRequestMethods = Object.freeze({
+    Post: 'POST',
+});
+/**
+ * Runtime-facing lifecycle values commonly used when searching stored
+ * `DeviceLicense` documents.
+ *
+ * These are not schema.org claims. They are operational filters that runtime
+ * layers may attach alongside the canonical schema.org claims.
+ */
+export const LicenseStatuses = Object.freeze({
+    Available: 'available',
+    Issued: 'issued',
+    Active: 'active',
+    Inactive: 'inactive',
+});
+function cloneClaims(claims) {
+    return { ...(claims || {}) };
+}
+/**
+ * Maps one canonical runtime user class to the schema.org-compatible
+ * `IndividualProduct.category` value used by current GW flows.
+ */
+export function mapLicenseCategoryFromUserClass(userClass = DeviceUserClasses.Employee) {
+    return userClass === DeviceUserClasses.Individual
+        ? LicenseCategories.Individual
+        : LicenseCategories.Professional;
+}
+/**
+ * Converts a list of seat ids / serial numbers into the compact string form
+ * currently stored in `org.schema.Offer.serialNumber`.
+ */
+export function serializeLicenseSerialNumbers(serialNumbers) {
+    const normalized = (serialNumbers || [])
+        .map((value) => String(value || '').trim())
+        .filter(Boolean);
+    return normalized.length > 0 ? normalized.join(',') : undefined;
+}
+/**
+ * Builds canonical `org.schema.*` claims for `License/_issue`.
+ *
+ * The resulting payload keeps current GW semantics:
+ * - recipient identity/role comes from `Person.*`
+ * - seat/app semantics come from `IndividualProduct.*`
+ */
+export function buildLicenseIssueClaims(input) {
+    const claims = {
+        '@context': LicenseClaimContext.SchemaOrg,
+        ...cloneClaims(input.additionalClaims),
+        [ClaimsPersonSchemaorg.email]: input.email.trim(),
+        [ClaimsPersonSchemaorg.hasOccupationalRoleValue]: input.role.trim(),
+        [ClaimsIndividualProductSchemaorg.category]: mapLicenseCategoryFromUserClass(input.userClass || DeviceUserClasses.Employee),
+        [ClaimsIndividualProductSchemaorg.additionalType]: input.type || DeviceAppTypes.Mobile,
+    };
+    return claims;
+}
+/**
+ * Builds the canonical batch entry for `License/_issue`.
+ */
+export function buildLicenseIssueEntry(input) {
+    return {
+        type: LicenseEntryTypes.Issue,
+        request: { method: LicenseRequestMethods.Post },
+        meta: {
+            claims: {
+                ...buildLicenseIssueClaims(input),
+                '@type': LicenseEntryOperations.Issue,
+            },
+        },
+    };
+}
+/**
+ * Builds canonical schema.org claims for a license purchase / seat-creation
+ * request.
+ *
+ * Current business semantics:
+ * - `Offer.eligibleQuantity.value` requests how many seats must exist
+ * - `Offer.serialNumber` can optionally carry the explicit seat ids when they
+ *   are already known or preallocated
+ * - `IndividualProduct.*` classifies the target seat family/form factor
+ */
+export function buildLicensePurchaseClaims(input) {
+    const claims = {
+        '@context': LicenseClaimContext.SchemaOrg,
+        ...cloneClaims(input.additionalClaims),
+        [ClaimsIndividualProductSchemaorg.category]: mapLicenseCategoryFromUserClass(input.userClass || DeviceUserClasses.Employee),
+        [ClaimsIndividualProductSchemaorg.additionalType]: input.type || DeviceAppTypes.Mobile,
+        [ClaimsOfferSchemaorg.eligibleQuantityValue]: input.quantity,
+    };
+    const serializedSerialNumbers = serializeLicenseSerialNumbers(input.serialNumbers);
+    if (serializedSerialNumbers) {
+        claims[ClaimsOfferSchemaorg.serialNumber] = serializedSerialNumbers;
+    }
+    return claims;
+}
+/**
+ * Builds the canonical batch entry for a purchase/order-oriented license
+ * request.
+ */
+export function buildLicensePurchaseEntry(input) {
+    return {
+        type: LicenseEntryTypes.Purchase,
+        request: { method: LicenseRequestMethods.Post },
+        meta: {
+            claims: {
+                ...buildLicensePurchaseClaims(input),
+                '@type': LicenseEntryOperations.Purchase,
+            },
+        },
+    };
+}
+/**
+ * Builds the canonical search envelope for license listing.
+ *
+ * Split of concerns:
+ * - schema.org-compatible selectors stay in `meta.claims`
+ * - document lifecycle stays in `meta.status`, mirroring the current
+ *   `ConfidentialStorageDoc.status` usage
+ * - `subjectId` remains an explicit side-field until a canonical indexed claim
+ *   is introduced for that lookup
+ */
+export function buildLicenseSearchEntry(input) {
+    const claims = {
+        '@context': LicenseClaimContext.SchemaOrg,
+        ...cloneClaims(input.additionalClaims),
+    };
+    if (input.serialNumbers && input.serialNumbers.length > 0) {
+        claims[ClaimsOfferSchemaorg.serialNumber] = serializeLicenseSerialNumbers(input.serialNumbers);
+    }
+    if (input.userClass) {
+        claims[ClaimsIndividualProductSchemaorg.category] = mapLicenseCategoryFromUserClass(input.userClass);
+    }
+    if (input.type) {
+        claims[ClaimsIndividualProductSchemaorg.additionalType] = input.type;
+    }
+    if (typeof input.email === 'string' && input.email.trim()) {
+        claims[ClaimsPersonSchemaorg.email] = input.email.trim();
+    }
+    if (typeof input.role === 'string' && input.role.trim()) {
+        claims[ClaimsPersonSchemaorg.hasOccupationalRoleValue] = input.role.trim();
+    }
+    return {
+        type: LicenseEntryTypes.Search,
+        request: { method: LicenseRequestMethods.Post },
+        meta: {
+            claims: {
+                ...claims,
+                '@type': LicenseEntryOperations.Search,
+            },
+            ...(input.status ? { status: input.status } : {}),
+            ...(typeof input.subjectId === 'string' && input.subjectId.trim()
+                ? { subjectId: input.subjectId.trim() }
+                : {}),
+        },
+    };
+}

package/dist/utils/service-act-reasons.d.ts

@@ -0,0 +1,16 @@
+export declare const HL7_ACT_REASON_CODE_SYSTEM = "http://terminology.hl7.org/CodeSystem/v3-ActReason";
+export type ServiceActReasonCoding = Readonly<{
+    system: string;
+    code: string;
+}>;
+/**
+ * Parses the compact CSV form used by flat GDC claims for `Service.additionalType`.
+ *
+ * Accepted examples:
+ * - `http://terminology.hl7.org/CodeSystem/v3-ActReason|METAMGT,HRESCH`
+ * - `http://terminology.hl7.org/CodeSystem/v3-ActReason|METAMGT,http://terminology.hl7.org/CodeSystem/v3-ActReason|HRESCH`
+ */
+export declare function parseServiceActReasonCodings(value: unknown): ServiceActReasonCoding[];
+export declare function parseServiceActReasonCodes(value: unknown): string[];
+export declare function serializeServiceActReasonCodings(values: ReadonlyArray<ServiceActReasonCoding | undefined | null>): string | undefined;
+export declare function serializeServiceActReasonCodes(codes: ReadonlyArray<string | undefined | null>, system?: string): string | undefined;

package/dist/utils/service-act-reasons.js

@@ -0,0 +1,68 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+export const HL7_ACT_REASON_CODE_SYSTEM = 'http://terminology.hl7.org/CodeSystem/v3-ActReason';
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeCoding(input) {
+    const system = normalizeText(input?.system);
+    const code = normalizeText(input?.code).toUpperCase();
+    if (!system || !code)
+        return undefined;
+    return { system, code };
+}
+/**
+ * Parses the compact CSV form used by flat GDC claims for `Service.additionalType`.
+ *
+ * Accepted examples:
+ * - `http://terminology.hl7.org/CodeSystem/v3-ActReason|METAMGT,HRESCH`
+ * - `http://terminology.hl7.org/CodeSystem/v3-ActReason|METAMGT,http://terminology.hl7.org/CodeSystem/v3-ActReason|HRESCH`
+ */
+export function parseServiceActReasonCodings(value) {
+    const raw = normalizeText(value);
+    if (!raw)
+        return [];
+    let currentSystem = '';
+    const codings = [];
+    for (const token of raw.split(',')) {
+        const normalizedToken = normalizeText(token);
+        if (!normalizedToken)
+            continue;
+        const pipeIndex = normalizedToken.indexOf('|');
+        if (pipeIndex >= 0) {
+            currentSystem = normalizeText(normalizedToken.slice(0, pipeIndex));
+            const coding = normalizeCoding({
+                system: currentSystem,
+                code: normalizedToken.slice(pipeIndex + 1),
+            });
+            if (coding)
+                codings.push(coding);
+            continue;
+        }
+        const coding = normalizeCoding({
+            system: currentSystem,
+            code: normalizedToken,
+        });
+        if (coding)
+            codings.push(coding);
+    }
+    return Array.from(new Map(codings.map((coding) => [`${coding.system}|${coding.code}`, coding])).values());
+}
+export function parseServiceActReasonCodes(value) {
+    return parseServiceActReasonCodings(value).map((coding) => coding.code);
+}
+export function serializeServiceActReasonCodings(values) {
+    const normalized = values
+        .map((value) => normalizeCoding(value || undefined))
+        .filter((value) => Boolean(value));
+    if (!normalized.length)
+        return undefined;
+    const unique = Array.from(new Map(normalized.map((coding) => [`${coding.system}|${coding.code}`, coding])).values());
+    const firstSystem = unique[0]?.system || '';
+    if (firstSystem && unique.every((coding) => coding.system === firstSystem)) {
+        return `${firstSystem}|${unique.map((coding) => coding.code).join(',')}`;
+    }
+    return unique.map((coding) => `${coding.system}|${coding.code}`).join(',');
+}
+export function serializeServiceActReasonCodes(codes, system = HL7_ACT_REASON_CODE_SYSTEM) {
+    return serializeServiceActReasonCodings(codes.map((code) => ({ system, code: normalizeText(code).toUpperCase() })));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "1.20.0",
+  "version": "1.20.2",
   "publishConfig": {
     "access": "public"
   },