vet-data-utils-ts 0.5.28 → 0.5.29

package/README.md

@@ -146,6 +146,15 @@ future PATCH. The matching `normalize*FlatClaimsResource()` functions reject
 nested FHIR persistence fields and unknown claims. Native FHIR JSON remains an
 explicit import, projection or export boundary.
 
+Animal-insurance eligibility Consent uses the same boundary through
+`vet-data-utils-ts/insurance-consent`: FHIR-equivalent authorization semantics
+live in canonical flat claims, the complete query-shaped ODRL Agreement lives
+in an `application/odrl+json` attachment, semantic divergence fails closed,
+and native R4/R5 appears only when explicitly requested. Aggregations such as
+"latest date" and "count" remain ODRL-only because FHIR Consent has no native
+field for them. See
+[`docs/insurance-consent-odrl.md`](docs/insurance-consent-odrl.md).
+
 Reusable Communication screens receive immutable workflow presets from
 `vet-data-utils-ts/communication`. The research-agreement screen is fixed to
 FHIR `notification` plus HL7 v3 ActReason `HRESCH` and does not expose a topic

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export * from './health-dcat.js';
 export * from './immunization.js';
 export * from './international-health-card.js';
 export * from './index-projection-tags.js';
+export * from './insurance-consent.js';
 export * from './iso-jurisdictions.js';
 export * from './organization-application.js';
 export * from './payment.js';

package/dist/index.js

@@ -11,6 +11,7 @@ export * from './health-dcat.js';
 export * from './immunization.js';
 export * from './international-health-card.js';
 export * from './index-projection-tags.js';
+export * from './insurance-consent.js';
 export * from './iso-jurisdictions.js';
 export * from './organization-application.js';
 export * from './payment.js';

package/dist/insurance-consent.d.ts

@@ -0,0 +1,126 @@
+import { ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants/fhir-resource-types';
+/** W3C ODRL and VetChain profile identifiers used by insurance eligibility consent. */
+export declare const AnimalInsuranceConsentVocabulary: Readonly<{
+    readonly OdrlContext: "http://www.w3.org/ns/odrl.jsonld";
+    readonly Agreement: "Agreement";
+    readonly Read: "read";
+    readonly Equal: "eq";
+    readonly GreaterThanOrEqual: "gteq";
+    readonly LessThanOrEqual: "lteq";
+    readonly MediaType: "application/odrl+json";
+    readonly Profile: "https://vetchain.app/ns/odrl/animal-insurance-eligibility/v1";
+    readonly EligibilitySummaryTarget: "https://vetchain.app/ns/asset/animal-insurance-eligibility-summary";
+    readonly FactKindOperand: "https://vetchain.app/ns/odrl/operand/eligibility-fact-kind";
+    readonly ClinicalCodeOperand: "https://vetchain.app/ns/odrl/operand/clinical-code";
+    readonly DataPeriodStartOperand: "https://vetchain.app/ns/odrl/operand/data-period-start";
+    readonly DataPeriodEndOperand: "https://vetchain.app/ns/odrl/operand/data-period-end";
+}>;
+export declare const AnimalInsuranceEligibilityFactKinds: Readonly<{
+    readonly LatestEventDate: "latest-event-date";
+    readonly EventCount: "event-count";
+}>;
+export declare const AnimalInsuranceConsentErrors: Readonly<{
+    readonly InvalidOdrl: "insurance_consent_odrl_invalid";
+    readonly OdrlClaimsDiverge: "insurance_consent_odrl_claims_diverge";
+    readonly ResearchForbidden: "insurance_consent_research_forbidden";
+    readonly FactsRequired: "insurance_consent_facts_required";
+}>;
+/** Reusable values for package, GW and portal contract tests. */
+export declare const ANIMAL_INSURANCE_CONSENT_TEST_DATA: Readonly<{
+    readonly consentId: "animal-insurance-consent-test-01";
+    readonly consentIdentifier: "urn:uuid:54b4d158-ed78-48b4-b006-84ba5a5d85b4";
+    readonly subjectReference: "Patient/animal-beneficiary-test-01";
+    readonly controllerReference: "RelatedPerson/controller-test-01";
+    readonly insurerReference: "Organization/animal-insurer-test-01";
+    readonly managerReference: "Organization/vetchain-consent-manager-test-01";
+    readonly enforcerReference: "Organization/vetchain-consent-enforcer-test-01";
+    readonly createdAt: "2026-09-08";
+    readonly consentPeriodStart: "2026-09-08T00:00:00Z";
+    readonly consentPeriodEnd: "2026-10-08T00:00:00Z";
+    readonly dataPeriodStart: "2025-09-08T00:00:00Z";
+    readonly dataPeriodEnd: "2026-09-08T00:00:00Z";
+    readonly actorRole: "http://terminology.hl7.org/CodeSystem/v3-RoleCode|PAYOR";
+    readonly action: "http://terminology.hl7.org/CodeSystem/consentaction|access";
+    readonly purpose: "http://terminology.hl7.org/CodeSystem/v3-ActReason|HOPERAT";
+    readonly scope: "http://terminology.hl7.org/CodeSystem/consentscope|patient-privacy";
+    readonly category: "http://loinc.org|59284-0";
+    readonly resourceType: "http://hl7.org/fhir/fhir-types|Observation";
+    readonly clinicalCode: "http://loinc.org|85353-1";
+    readonly secondClinicalCode: "http://loinc.org|8310-5";
+    readonly clinicalCodeList: "http://loinc.org|85353-1,http://loinc.org|8310-5";
+    readonly status: "active";
+    readonly decision: "permit";
+    readonly factKind: "latest-event-date";
+    readonly forbiddenPurpose: "http://terminology.hl7.org/CodeSystem/v3-ActReason|HRESCH";
+    readonly divergentInsurerReference: "Organization/different-animal-insurer-test-01";
+    readonly jurisdiction: "CA";
+    readonly fhirConsentResourceType: "Consent";
+}>;
+export type AnimalInsuranceEligibilityFact = Readonly<{
+    kind: typeof AnimalInsuranceEligibilityFactKinds[keyof typeof AnimalInsuranceEligibilityFactKinds];
+    clinicalCode: string;
+}>;
+export type AnimalInsuranceConsentInput = Readonly<{
+    id: string;
+    identifier: string;
+    subjectReference: string;
+    grantorReference: string;
+    granteeReference: string;
+    managerReference: string;
+    controllerReference: string;
+    createdAt: string;
+    consentPeriod: Readonly<{
+        start: string;
+        end: string;
+    }>;
+    dataPeriod: Readonly<{
+        start: string;
+        end: string;
+    }>;
+    actorRole: string;
+    action: string;
+    purpose: string;
+    scope: string;
+    category: string;
+    resourceType: string;
+    facts: readonly AnimalInsuranceEligibilityFact[];
+}>;
+/** Complete reusable builder input used by downstream GW, SDK and portal tests. */
+export declare const ANIMAL_INSURANCE_CONSENT_TEST_INPUT: AnimalInsuranceConsentInput;
+export type ClaimsFirstAnimalInsuranceConsent = Readonly<{
+    resourceType: typeof ResourceTypesFhirR4.Consent;
+    id: string;
+    meta: Readonly<{
+        claims: Readonly<Record<string, string>>;
+    }>;
+}>;
+export type AnimalInsuranceOdrlConstraint = Readonly<{
+    leftOperand: string;
+    operator: string;
+    rightOperand: string;
+}>;
+export type AnimalInsuranceOdrlPolicy = Readonly<{
+    '@context': typeof AnimalInsuranceConsentVocabulary.OdrlContext;
+    '@type': typeof AnimalInsuranceConsentVocabulary.Agreement;
+    uid: string;
+    profile: typeof AnimalInsuranceConsentVocabulary.Profile;
+    assigner: string;
+    assignee: string;
+    permission: readonly Readonly<{
+        target: typeof AnimalInsuranceConsentVocabulary.EligibilitySummaryTarget;
+        action: typeof AnimalInsuranceConsentVocabulary.Read;
+        constraint: readonly AnimalInsuranceOdrlConstraint[];
+    }>[];
+}>;
+/**
+ * Builds an atomic claims-first FHIR Consent for one insurer eligibility query.
+ * Standard authorization semantics are mirrored in flat Consent claims; the
+ * complete query-shaping policy remains an ODRL JSON attachment.
+ */
+export declare function buildAnimalInsuranceEligibilityConsent(input: AnimalInsuranceConsentInput): ClaimsFirstAnimalInsuranceConsent;
+/** Parses the attached ODRL and fails closed unless its authorization semantics match the claims. */
+export declare function validateAnimalInsuranceConsentOdrlParity(resource: ClaimsFirstAnimalInsuranceConsent): AnimalInsuranceOdrlPolicy;
+/** Validates parity, then exports a native FHIR R4 Consent without ODRL-only fields. */
+export declare function projectAnimalInsuranceConsentToFhirR4(resource: ClaimsFirstAnimalInsuranceConsent): Record<string, unknown>;
+/** Validates parity, then exports a native FHIR R5 Consent without ODRL-only fields. */
+export declare function projectAnimalInsuranceConsentToFhirR5(resource: ClaimsFirstAnimalInsuranceConsent): Record<string, unknown>;

package/dist/insurance-consent.js

@@ -0,0 +1,228 @@
+import { ClaimConsent, ConsentDecisions, ConsentStatuses, } from 'gdc-common-utils-ts/models/consent-rule';
+import { HealthcareConsentPurposes, } from 'gdc-common-utils-ts/constants/healthcare';
+import { ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants/fhir-resource-types';
+import { consentFlatToFhirR4, consentFlatToFhirR5, } from 'gdc-common-utils-ts/convert/convert-consent';
+/** W3C ODRL and VetChain profile identifiers used by insurance eligibility consent. */
+export const AnimalInsuranceConsentVocabulary = Object.freeze({
+    OdrlContext: 'http://www.w3.org/ns/odrl.jsonld',
+    Agreement: 'Agreement',
+    Read: 'read',
+    Equal: 'eq',
+    GreaterThanOrEqual: 'gteq',
+    LessThanOrEqual: 'lteq',
+    MediaType: 'application/odrl+json',
+    Profile: 'https://vetchain.app/ns/odrl/animal-insurance-eligibility/v1',
+    EligibilitySummaryTarget: 'https://vetchain.app/ns/asset/animal-insurance-eligibility-summary',
+    FactKindOperand: 'https://vetchain.app/ns/odrl/operand/eligibility-fact-kind',
+    ClinicalCodeOperand: 'https://vetchain.app/ns/odrl/operand/clinical-code',
+    DataPeriodStartOperand: 'https://vetchain.app/ns/odrl/operand/data-period-start',
+    DataPeriodEndOperand: 'https://vetchain.app/ns/odrl/operand/data-period-end',
+});
+export const AnimalInsuranceEligibilityFactKinds = Object.freeze({
+    LatestEventDate: 'latest-event-date',
+    EventCount: 'event-count',
+});
+export const AnimalInsuranceConsentErrors = Object.freeze({
+    InvalidOdrl: 'insurance_consent_odrl_invalid',
+    OdrlClaimsDiverge: 'insurance_consent_odrl_claims_diverge',
+    ResearchForbidden: 'insurance_consent_research_forbidden',
+    FactsRequired: 'insurance_consent_facts_required',
+});
+/** Reusable values for package, GW and portal contract tests. */
+export const ANIMAL_INSURANCE_CONSENT_TEST_DATA = Object.freeze({
+    consentId: 'animal-insurance-consent-test-01',
+    consentIdentifier: 'urn:uuid:54b4d158-ed78-48b4-b006-84ba5a5d85b4',
+    subjectReference: 'Patient/animal-beneficiary-test-01',
+    controllerReference: 'RelatedPerson/controller-test-01',
+    insurerReference: 'Organization/animal-insurer-test-01',
+    managerReference: 'Organization/vetchain-consent-manager-test-01',
+    enforcerReference: 'Organization/vetchain-consent-enforcer-test-01',
+    createdAt: '2026-09-08',
+    consentPeriodStart: '2026-09-08T00:00:00Z',
+    consentPeriodEnd: '2026-10-08T00:00:00Z',
+    dataPeriodStart: '2025-09-08T00:00:00Z',
+    dataPeriodEnd: '2026-09-08T00:00:00Z',
+    actorRole: 'http://terminology.hl7.org/CodeSystem/v3-RoleCode|PAYOR',
+    action: 'http://terminology.hl7.org/CodeSystem/consentaction|access',
+    purpose: `http://terminology.hl7.org/CodeSystem/v3-ActReason|${HealthcareConsentPurposes.Operations}`,
+    scope: 'http://terminology.hl7.org/CodeSystem/consentscope|patient-privacy',
+    category: 'http://loinc.org|59284-0',
+    resourceType: 'http://hl7.org/fhir/fhir-types|Observation',
+    clinicalCode: 'http://loinc.org|85353-1',
+    secondClinicalCode: 'http://loinc.org|8310-5',
+    clinicalCodeList: 'http://loinc.org|85353-1,http://loinc.org|8310-5',
+    status: ConsentStatuses.Active,
+    decision: ConsentDecisions.Permit,
+    factKind: AnimalInsuranceEligibilityFactKinds.LatestEventDate,
+    forbiddenPurpose: `http://terminology.hl7.org/CodeSystem/v3-ActReason|${HealthcareConsentPurposes.Research}`,
+    divergentInsurerReference: 'Organization/different-animal-insurer-test-01',
+    jurisdiction: 'CA',
+    fhirConsentResourceType: ResourceTypesFhirR4.Consent,
+});
+/** Complete reusable builder input used by downstream GW, SDK and portal tests. */
+export const ANIMAL_INSURANCE_CONSENT_TEST_INPUT = Object.freeze({
+    id: ANIMAL_INSURANCE_CONSENT_TEST_DATA.consentId,
+    identifier: ANIMAL_INSURANCE_CONSENT_TEST_DATA.consentIdentifier,
+    subjectReference: ANIMAL_INSURANCE_CONSENT_TEST_DATA.subjectReference,
+    grantorReference: ANIMAL_INSURANCE_CONSENT_TEST_DATA.controllerReference,
+    granteeReference: ANIMAL_INSURANCE_CONSENT_TEST_DATA.insurerReference,
+    managerReference: ANIMAL_INSURANCE_CONSENT_TEST_DATA.managerReference,
+    controllerReference: ANIMAL_INSURANCE_CONSENT_TEST_DATA.enforcerReference,
+    createdAt: ANIMAL_INSURANCE_CONSENT_TEST_DATA.createdAt,
+    consentPeriod: Object.freeze({
+        start: ANIMAL_INSURANCE_CONSENT_TEST_DATA.consentPeriodStart,
+        end: ANIMAL_INSURANCE_CONSENT_TEST_DATA.consentPeriodEnd,
+    }),
+    dataPeriod: Object.freeze({
+        start: ANIMAL_INSURANCE_CONSENT_TEST_DATA.dataPeriodStart,
+        end: ANIMAL_INSURANCE_CONSENT_TEST_DATA.dataPeriodEnd,
+    }),
+    actorRole: ANIMAL_INSURANCE_CONSENT_TEST_DATA.actorRole,
+    action: ANIMAL_INSURANCE_CONSENT_TEST_DATA.action,
+    purpose: ANIMAL_INSURANCE_CONSENT_TEST_DATA.purpose,
+    scope: ANIMAL_INSURANCE_CONSENT_TEST_DATA.scope,
+    category: ANIMAL_INSURANCE_CONSENT_TEST_DATA.category,
+    resourceType: ANIMAL_INSURANCE_CONSENT_TEST_DATA.resourceType,
+    facts: Object.freeze([{
+            kind: ANIMAL_INSURANCE_CONSENT_TEST_DATA.factKind,
+            clinicalCode: ANIMAL_INSURANCE_CONSENT_TEST_DATA.clinicalCode,
+        }, {
+            kind: AnimalInsuranceEligibilityFactKinds.EventCount,
+            clinicalCode: ANIMAL_INSURANCE_CONSENT_TEST_DATA.secondClinicalCode,
+        }]),
+});
+function encodeBase64Utf8(value) {
+    const bytes = new TextEncoder().encode(value);
+    let binary = '';
+    bytes.forEach((byte) => { binary += String.fromCharCode(byte); });
+    return btoa(binary);
+}
+function decodeBase64Utf8(value) {
+    const binary = atob(value);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}
+function buildPolicy(input) {
+    return {
+        '@context': AnimalInsuranceConsentVocabulary.OdrlContext,
+        '@type': AnimalInsuranceConsentVocabulary.Agreement,
+        uid: input.identifier,
+        profile: AnimalInsuranceConsentVocabulary.Profile,
+        assigner: input.grantorReference,
+        assignee: input.granteeReference,
+        permission: input.facts.map((fact) => ({
+            target: AnimalInsuranceConsentVocabulary.EligibilitySummaryTarget,
+            action: AnimalInsuranceConsentVocabulary.Read,
+            constraint: [
+                { leftOperand: AnimalInsuranceConsentVocabulary.FactKindOperand, operator: AnimalInsuranceConsentVocabulary.Equal, rightOperand: fact.kind },
+                { leftOperand: AnimalInsuranceConsentVocabulary.ClinicalCodeOperand, operator: AnimalInsuranceConsentVocabulary.Equal, rightOperand: fact.clinicalCode },
+                { leftOperand: AnimalInsuranceConsentVocabulary.DataPeriodStartOperand, operator: AnimalInsuranceConsentVocabulary.GreaterThanOrEqual, rightOperand: input.dataPeriod.start },
+                { leftOperand: AnimalInsuranceConsentVocabulary.DataPeriodEndOperand, operator: AnimalInsuranceConsentVocabulary.LessThanOrEqual, rightOperand: input.dataPeriod.end },
+            ],
+        })),
+    };
+}
+function rejectResearchSemantics(input) {
+    if (input.purpose.split('|').at(-1) === HealthcareConsentPurposes.Research
+        || input.resourceType.split('|').at(-1) === ResourceTypesFhirR4.ResearchStudy) {
+        throw new TypeError(AnimalInsuranceConsentErrors.ResearchForbidden);
+    }
+}
+/**
+ * Builds an atomic claims-first FHIR Consent for one insurer eligibility query.
+ * Standard authorization semantics are mirrored in flat Consent claims; the
+ * complete query-shaping policy remains an ODRL JSON attachment.
+ */
+export function buildAnimalInsuranceEligibilityConsent(input) {
+    rejectResearchSemantics(input);
+    if (!input.facts.length)
+        throw new TypeError(AnimalInsuranceConsentErrors.FactsRequired);
+    if (input.facts.some((fact) => !Object.values(AnimalInsuranceEligibilityFactKinds).includes(fact.kind))) {
+        throw new TypeError(AnimalInsuranceConsentErrors.InvalidOdrl);
+    }
+    const policy = buildPolicy(input);
+    return {
+        resourceType: ResourceTypesFhirR4.Consent,
+        id: input.id,
+        meta: {
+            claims: {
+                '@context': 'org.hl7.fhir.api',
+                [ClaimConsent.identifier]: input.identifier,
+                [ClaimConsent.status]: ConsentStatuses.Active,
+                [ClaimConsent.subject]: input.subjectReference,
+                [ClaimConsent.date]: input.createdAt,
+                [ClaimConsent.decision]: ConsentDecisions.Permit,
+                [ClaimConsent.periodStart]: input.consentPeriod.start,
+                [ClaimConsent.periodEnd]: input.consentPeriod.end,
+                [ClaimConsent.dataPeriodStart]: input.dataPeriod.start,
+                [ClaimConsent.dataPeriodEnd]: input.dataPeriod.end,
+                [ClaimConsent.grantor]: input.grantorReference,
+                [ClaimConsent.grantee]: input.granteeReference,
+                [ClaimConsent.manager]: input.managerReference,
+                [ClaimConsent.controller]: input.controllerReference,
+                [ClaimConsent.actorIdentifier]: input.granteeReference,
+                [ClaimConsent.actorRole]: input.actorRole,
+                [ClaimConsent.action]: input.action,
+                [ClaimConsent.purpose]: input.purpose,
+                [ClaimConsent.scope]: input.scope,
+                [ClaimConsent.category]: input.category,
+                [ClaimConsent.resourceType]: input.resourceType,
+                [ClaimConsent.provisionCode]: input.facts.map((fact) => fact.clinicalCode).join(','),
+                [ClaimConsent.attachmentContentType]: AnimalInsuranceConsentVocabulary.MediaType,
+                [ClaimConsent.attachmentData]: encodeBase64Utf8(JSON.stringify(policy)),
+            },
+        },
+    };
+}
+function constraintValue(permission, operand) {
+    return permission.constraint.find((constraint) => constraint.leftOperand === operand)?.rightOperand;
+}
+/** Parses the attached ODRL and fails closed unless its authorization semantics match the claims. */
+export function validateAnimalInsuranceConsentOdrlParity(resource) {
+    const claims = resource?.meta?.claims;
+    if (resource?.resourceType !== ResourceTypesFhirR4.Consent
+        || claims?.[ClaimConsent.attachmentContentType] !== AnimalInsuranceConsentVocabulary.MediaType) {
+        throw new TypeError(AnimalInsuranceConsentErrors.InvalidOdrl);
+    }
+    let policy;
+    try {
+        policy = JSON.parse(decodeBase64Utf8(claims[ClaimConsent.attachmentData]));
+    }
+    catch {
+        throw new TypeError(AnimalInsuranceConsentErrors.InvalidOdrl);
+    }
+    const permissions = Array.isArray(policy.permission) ? policy.permission : [];
+    const codes = permissions.map((permission) => constraintValue(permission, AnimalInsuranceConsentVocabulary.ClinicalCodeOperand)).filter(Boolean);
+    const periodsMatch = permissions.every((permission) => constraintValue(permission, AnimalInsuranceConsentVocabulary.DataPeriodStartOperand) === claims[ClaimConsent.dataPeriodStart]
+        && constraintValue(permission, AnimalInsuranceConsentVocabulary.DataPeriodEndOperand) === claims[ClaimConsent.dataPeriodEnd]);
+    const coreMatches = policy['@context'] === AnimalInsuranceConsentVocabulary.OdrlContext
+        && policy['@type'] === AnimalInsuranceConsentVocabulary.Agreement
+        && policy.profile === AnimalInsuranceConsentVocabulary.Profile
+        && policy.uid === claims[ClaimConsent.identifier]
+        && policy.assigner === claims[ClaimConsent.grantor]
+        && policy.assignee === claims[ClaimConsent.grantee]
+        && claims[ClaimConsent.actorIdentifier] === claims[ClaimConsent.grantee]
+        && claims[ClaimConsent.decision] === ConsentDecisions.Permit
+        && permissions.length > 0
+        && permissions.every((permission) => permission.target === AnimalInsuranceConsentVocabulary.EligibilitySummaryTarget
+            && permission.action === AnimalInsuranceConsentVocabulary.Read)
+        && codes.join(',') === claims[ClaimConsent.provisionCode]
+        && periodsMatch;
+    if (!coreMatches)
+        throw new TypeError(AnimalInsuranceConsentErrors.OdrlClaimsDiverge);
+    rejectResearchSemantics({
+        purpose: claims[ClaimConsent.purpose],
+        resourceType: claims[ClaimConsent.resourceType],
+    });
+    return policy;
+}
+/** Validates parity, then exports a native FHIR R4 Consent without ODRL-only fields. */
+export function projectAnimalInsuranceConsentToFhirR4(resource) {
+    validateAnimalInsuranceConsentOdrlParity(resource);
+    return consentFlatToFhirR4(resource.meta.claims);
+}
+/** Validates parity, then exports a native FHIR R5 Consent without ODRL-only fields. */
+export function projectAnimalInsuranceConsentToFhirR5(resource) {
+    validateAnimalInsuranceConsentOdrlParity(resource);
+    return consentFlatToFhirR5(resource.meta.claims);
+}

package/dist/scheduling.d.ts

@@ -38,7 +38,7 @@ export declare const SchedulingSearchParameterCatalog: Readonly<{
     readonly AppointmentResponse: readonly string[];
 }>;
 /** Indexed scheduling claims: FHIR SearchParameters plus the governed generic user-selected extension. */
-export declare const SchedulingFlatClaimCatalog: Readonly<Record<"Location" | "Schedule" | "Appointment" | "AppointmentResponse" | "Slot", readonly string[]>>;
+export declare const SchedulingFlatClaimCatalog: Readonly<Record<"Appointment" | "AppointmentResponse" | "Location" | "Schedule" | "Slot", readonly string[]>>;
 export type SchedulingResourceType = keyof typeof SchedulingFlatClaimCatalog;
 export type SchedulingFlatClaimsResource = Readonly<Record<string, unknown> & {
     resourceType: SchedulingResourceType;
@@ -163,7 +163,7 @@ export declare function buildAppointmentNotificationResource(input: Readonly<{
 /** @deprecated Use {@link SlotSearchParameters}. */
 export declare const VeterinarySlotSearchParameters: readonly ["appointment-type", "identifier", "schedule", "service-category", "service-type", "service-type-reference", "specialty", "start", "status"];
 /** @deprecated Use {@link SchedulingFlatClaimCatalog}. */
-export declare const VeterinarySchedulingFlatClaimCatalog: Readonly<Record<"Location" | "Schedule" | "Appointment" | "AppointmentResponse" | "Slot", readonly string[]>>;
+export declare const VeterinarySchedulingFlatClaimCatalog: Readonly<Record<"Appointment" | "AppointmentResponse" | "Location" | "Schedule" | "Slot", readonly string[]>>;
 /** @deprecated Use {@link SchedulingResourceType}. */
 export type VeterinarySchedulingResourceType = SchedulingResourceType;
 /** @deprecated Use {@link SchedulingFlatClaimsResource}. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-data-utils-ts",
-  "version": "0.5.28",
+  "version": "0.5.29",
   "description": "Browser-safe governed VetChain data contracts",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -60,6 +60,10 @@
       "types": "./dist/index-projection-tags.d.ts",
       "default": "./dist/index-projection-tags.js"
     },
+    "./insurance-consent": {
+      "types": "./dist/insurance-consent.d.ts",
+      "default": "./dist/insurance-consent.js"
+    },
     "./iso-jurisdictions": {
       "types": "./dist/iso-jurisdictions.d.ts",
       "default": "./dist/iso-jurisdictions.js"
@@ -125,7 +129,7 @@
     "typescript": "^5.5.4"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "2.9.10",
+    "gdc-common-utils-ts": "2.9.12",
     "pako": "^2.2.0"
   },
   "engines": {