vet-data-utils-ts 0.5.28 → 0.5.30

package/README.md

@@ -1,5 +1,18 @@
 # vet-data-utils-ts
 
+## Lost-animal access and behavior
+
+`normalizeIso3166Jurisdiction(...)` and
+`buildLostAnimalEmergencyJurisdictionActors(...)` create exact country or
+subdivision Consent actors such as `urn:iso:3166-2:CA-BC`. The
+`LostAnimalEmergencyAccess` profile limits standing access to licensed
+veterinarians, emergency treatment and a minimal veterinary summary. GW still
+verifies the credential, active licence, route jurisdiction and exact animal.
+
+`buildAnimalBehaviorObservation(...)` records controller-reported temperament
+and fear context as a claims-first social-history Observation. It deliberately
+uses narrative text rather than inventing a veterinary diagnosis code.
+
 The product-local `place-service-directory` export models persistent public
 sites as claims-only Schema.org `Place` resources and their offerings as
 claims-only `Service` or `Product` resources. A care organization publishes
@@ -146,6 +159,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/animal-behavior.d.ts

@@ -0,0 +1,18 @@
+export type AnimalBehaviorObservationInput = Readonly<{
+    id: string;
+    subject: string;
+    observedAt: string;
+    language: string;
+    summary: string;
+    note?: string;
+    localLabel?: string;
+}>;
+export type AnimalBehaviorObservation = Readonly<{
+    resourceType: 'Observation';
+    id: string;
+    meta: Readonly<{
+        claims: Readonly<Record<string, string>>;
+    }>;
+}>;
+/** Builds one claims-first, controller-reported behavior Observation without inventing a diagnosis code. */
+export declare function buildAnimalBehaviorObservation(input: AnimalBehaviorObservationInput): AnimalBehaviorObservation;

package/dist/animal-behavior.js

@@ -0,0 +1,44 @@
+import { ObservationCategoryCodes } from 'gdc-common-utils-ts/constants/observation-category';
+import { ObservationClaim } from 'gdc-common-utils-ts/models/interoperable-claims/observation-claims';
+import { isVetChainAnimalCardDid } from './animal-card.js';
+const ENGLISH_DISPLAY = 'Animal temperament and fear response';
+function boundedText(value, name, max) {
+    const normalized = String(value || '').trim();
+    if (!normalized || normalized.length > max)
+        throw new TypeError(`animal_behavior_${name}_invalid`);
+    return normalized;
+}
+/** Builds one claims-first, controller-reported behavior Observation without inventing a diagnosis code. */
+export function buildAnimalBehaviorObservation(input) {
+    const id = String(input.id || '').trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(id))
+        throw new TypeError('animal_behavior_id_invalid');
+    const subject = String(input.subject || '').trim();
+    if (!isVetChainAnimalCardDid(subject))
+        throw new TypeError('animal_behavior_animal_card_did_required');
+    const observedAt = String(input.observedAt || '').trim();
+    if (!observedAt || Number.isNaN(Date.parse(observedAt)))
+        throw new TypeError('animal_behavior_observedAt_invalid');
+    const language = String(input.language || '').trim();
+    if (!/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(language))
+        throw new TypeError('animal_behavior_language_invalid');
+    const summary = boundedText(input.summary, 'summary', 1000);
+    const note = input.note === undefined ? undefined : boundedText(input.note, 'note', 1000);
+    const localLabel = input.localLabel === undefined ? ENGLISH_DISPLAY : boundedText(input.localLabel, 'local_label', 120);
+    const claims = {
+        '@context': 'org.hl7.fhir.api',
+        [ObservationClaim.Identifier]: id,
+        [ObservationClaim.Subject]: subject,
+        [ObservationClaim.Status]: 'final',
+        [ObservationClaim.Category]: ObservationCategoryCodes.SocialHistory.claim,
+        [ObservationClaim.CodeText]: localLabel,
+        [ObservationClaim.CodeDisplay]: ENGLISH_DISPLAY,
+        [ObservationClaim.ValueString]: summary,
+        [ObservationClaim.Date]: observedAt,
+        [ObservationClaim.EffectiveDateTime]: observedAt,
+        [ObservationClaim.Language]: language,
+    };
+    if (note)
+        claims[ObservationClaim.Note] = note;
+    return Object.freeze({ resourceType: 'Observation', id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './animal-card.js';
+export * from './animal-behavior.js';
 export * from './assistant.js';
 export * from './communication.js';
 export * from './clinical-terminology.js';
@@ -11,7 +12,9 @@ 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 './lost-animal-access.js';
 export * from './organization-application.js';
 export * from './payment.js';
 export * from './place-service-directory.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './animal-card.js';
+export * from './animal-behavior.js';
 export * from './assistant.js';
 export * from './communication.js';
 export * from './clinical-terminology.js';
@@ -11,7 +12,9 @@ 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 './lost-animal-access.js';
 export * from './organization-application.js';
 export * from './payment.js';
 export * from './place-service-directory.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/lost-animal-access.d.ts

@@ -0,0 +1,23 @@
+export type Iso3166Jurisdiction = Readonly<{
+    code: string;
+    countryCode: string;
+    kind: 'country' | 'subdivision';
+    actorIdentifier: string;
+}>;
+/** Normalizes an ISO 3166 country or subdivision into its canonical Consent actor. */
+export declare function normalizeIso3166Jurisdiction(input: unknown): Iso3166Jurisdiction;
+/** Builds a deterministic, duplicate-free actor list for controller-authored regional Consent rules. */
+export declare function buildLostAnimalEmergencyJurisdictionActors(input: readonly unknown[]): readonly string[];
+/**
+ * Least-privilege standing access profile for a lost animal.
+ *
+ * A matching rule is not proof that the requester is a veterinarian: GW must
+ * independently verify the professional credential, active licence, route
+ * jurisdiction and exact animal subject before issuing a short-lived token.
+ */
+export declare const LostAnimalEmergencyAccess: Readonly<{
+    actorRole: "ISCO-08|2250";
+    purpose: "ETREAT";
+    resourceTypes: readonly ["Composition"];
+    sections: readonly `LOINC|${string}`[];
+}>;

package/dist/lost-animal-access.js

@@ -0,0 +1,45 @@
+import { HealthcareActorRoles, HealthcareConsentPurposes } from 'gdc-common-utils-ts/constants/healthcare';
+import { isIso3166CountryCode, isIso3166SubdivisionForCountry } from './iso-jurisdictions.js';
+import { VeterinarySummarySections } from './veterinary-sections.js';
+const countryActor = /^urn:iso:3166:([a-z]{2})$/i;
+const subdivisionActor = /^urn:iso:3166-2:([a-z]{2}-[a-z0-9]{1,3})$/i;
+/** Normalizes an ISO 3166 country or subdivision into its canonical Consent actor. */
+export function normalizeIso3166Jurisdiction(input) {
+    const raw = String(input || '').trim();
+    const unwrapped = countryActor.exec(raw)?.[1] || subdivisionActor.exec(raw)?.[1] || raw;
+    const code = unwrapped.toUpperCase();
+    const countryCode = code.slice(0, 2);
+    if (code.length === 2 && isIso3166CountryCode(code)) {
+        return Object.freeze({ code, countryCode, kind: 'country', actorIdentifier: `urn:iso:3166:${code}` });
+    }
+    if (isIso3166CountryCode(countryCode) && isIso3166SubdivisionForCountry(code, countryCode)) {
+        return Object.freeze({ code, countryCode, kind: 'subdivision', actorIdentifier: `urn:iso:3166-2:${code}` });
+    }
+    throw new TypeError('lost_animal_access_iso_3166_jurisdiction_invalid');
+}
+/** Builds a deterministic, duplicate-free actor list for controller-authored regional Consent rules. */
+export function buildLostAnimalEmergencyJurisdictionActors(input) {
+    if (!Array.isArray(input) || input.length === 0)
+        throw new TypeError('lost_animal_access_jurisdiction_required');
+    return Object.freeze([...new Set(input.map(value => normalizeIso3166Jurisdiction(value).actorIdentifier))]);
+}
+/**
+ * Least-privilege standing access profile for a lost animal.
+ *
+ * A matching rule is not proof that the requester is a veterinarian: GW must
+ * independently verify the professional credential, active licence, route
+ * jurisdiction and exact animal subject before issuing a short-lived token.
+ */
+export const LostAnimalEmergencyAccess = Object.freeze({
+    actorRole: HealthcareActorRoles.Veterinarian,
+    purpose: HealthcareConsentPurposes.EmergencyTreatment,
+    resourceTypes: Object.freeze(['Composition']),
+    sections: Object.freeze([
+        VeterinarySummarySections.Alerts.value,
+        VeterinarySummarySections.Allergies.value,
+        VeterinarySummarySections.Medications.value,
+        VeterinarySummarySections.Immunizations.value,
+        VeterinarySummarySections.Problems.value,
+        VeterinarySummarySections.EnvironmentAndLifestyle.value,
+    ]),
+});

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.30",
   "description": "Browser-safe governed VetChain data contracts",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -16,6 +16,10 @@
       "types": "./dist/animal-card.d.ts",
       "default": "./dist/animal-card.js"
     },
+    "./animal-behavior": {
+      "types": "./dist/animal-behavior.d.ts",
+      "default": "./dist/animal-behavior.js"
+    },
     "./communication": {
       "types": "./dist/communication.d.ts",
       "default": "./dist/communication.js"
@@ -60,10 +64,18 @@
       "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"
     },
+    "./lost-animal-access": {
+      "types": "./dist/lost-animal-access.d.ts",
+      "default": "./dist/lost-animal-access.js"
+    },
     "./organization-application": {
       "types": "./dist/organization-application.d.ts",
       "default": "./dist/organization-application.js"
@@ -125,7 +137,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": {