vet-data-utils-ts 0.6.0 → 0.7.1

package/README.md

@@ -26,9 +26,10 @@ The product-local `place-service-directory` export models persistent public
 departments as claims-only Schema.org `Organization` resources, their sites as
 `Place`, and their offerings as `Service` or `Product`. A department has one
 parent legal organization, one or more Places and several offered Services.
-`projectDepartmentToFhirR5HealthcareService(...)` aggregates those Services
-into exactly one stable FHIR `HealthcareService` per department; an offered
-Service is not a second department or communication sender. A care organization
+Each offered Service projects through
+`projectServiceToFhirR5HealthcareService(...)` to its own stable FHIR
+`HealthcareService`; the department remains the provider Organization and
+communication sender. The old aggregate department projection fails closed. A care organization
 publishes services; an insurance organization publishes products in a
 Schema.org `OfferCatalog`. Logos, images, accessibility, coordinates, address
 and opening-hours specifications remain neutral indexed claims. Native FHIR R5
@@ -126,6 +127,25 @@ and applies weekly or monthly-ordinal exceptions that restrict or extend one or
 more consultation Locations. It converts clinic-local times through an IANA
 time zone, including daylight-saving changes.
 
+Every Schedule identifies exactly one HealthcareService and the resources that
+must be available together. A child Location is the independently reservable
+capacity unit; `PractitionerRole` and `Device` actors are optional and included
+only when that professional or particular machine constrains capacity. Slot duration comes only from its start/end instants.
+Schedule and Slot business identity is independent from those mutable actors.
+Callers supply one canonical service-owned Schedule URN for each reservable
+Location. `Schedule.identifier` preserves that URN and `Schedule.id` is its
+SHA3-256 base58btc multihash. `Slot.identifier` appends one
+`<startEpochSeconds>-<endEpochSeconds>` interval segment and `Slot.id` is
+derived the same way. Do not concatenate practitioner, Location, Device or DID
+values into either identity.
+Reservable rooms, booths, chairs and beds are child Locations; machines remain
+Devices. The neutral builders and canonical Schedule/Slot claim catalogs come
+from `fhir-data-utils-ts` rather than being duplicated here.
+
+An equipment failure is not itself an appointment cancellation. The equipment
+record captures the fault or availability change; scheduling separately marks
+only the affected future Slots unavailable and reconciles their appointments.
+
 The official searchable facts remain resource-qualified flat claims. The
 exported `VeterinarySlotSearchParameters` catalogue identifies the supported
 FHIR R5 Slot query codes; generated resources include `Slot.identifier`,

package/dist/animal-identity-assurance.d.ts

@@ -0,0 +1,182 @@
+export declare const VeterinaryAnimalIdentityCredentialTypes: Readonly<{
+    Assurance: "VeterinaryAnimalIdentityAssuranceCredential";
+}>;
+export type VeterinaryAnimalControllerRelationship = 'owner' | 'caregiver';
+export type VeterinaryIdentityDocumentDigest = Readonly<{
+    contentType: 'application/pdf' | 'image/jpeg' | 'image/png';
+    /** SHA3-384 multihash encoded as base58btc. Raw document bytes never belong in the credential. */
+    sha3_384: string;
+}>;
+export type VeterinaryAnimalIdentityAssuranceCredential = Readonly<{
+    '@context': readonly ['https://www.w3.org/ns/credentials/v2', 'https://schema.org'];
+    id: string;
+    type: readonly ['VerifiableCredential', 'VeterinaryAnimalIdentityAssuranceCredential'];
+    issuer: string;
+    validFrom: string;
+    validUntil: string;
+    credentialSubject: Readonly<{
+        id: string;
+        '@type': 'Person';
+        holdsAnimalIdentity: Readonly<{
+            id: string;
+            '@type': 'Animal';
+            name: string;
+            species: Readonly<{
+                '@type': 'Taxon';
+                taxonRank: 'species';
+                identifier: string;
+            }>;
+            identifier: Readonly<{
+                '@type': 'PropertyValue';
+                propertyID: string;
+                value: string;
+            }>;
+        }>;
+        relationshipToAnimal: VeterinaryAnimalControllerRelationship;
+        verified_claims: Readonly<{
+            verification: Readonly<{
+                trust_framework: 'veterinarian_in_person_document_check';
+                time: string;
+                verification_process: string;
+                evidence: readonly [
+                    Readonly<{
+                        type: 'document';
+                        method: 'physical_in_person_check';
+                        verifier: Readonly<{
+                            organization: string;
+                            professional: string;
+                            role: 'ISCO-08|2250';
+                        }>;
+                        time: string;
+                        check_details: readonly [Readonly<{
+                            check_method: 'physical_in_person_check';
+                            time: string;
+                        }>];
+                        attachments: Readonly<{
+                            content_type: string;
+                            digest: Readonly<{
+                                alg: 'sha3-384';
+                                value: string;
+                            }>;
+                        }>;
+                    }>
+                ];
+            }>;
+            claims: Readonly<{
+                name: string;
+                identifier: Readonly<{
+                    type: string;
+                    value: string;
+                    country: string;
+                }>;
+            }>;
+        }>;
+    }>;
+    evidence: readonly [
+        Readonly<{
+            type: 'VeterinaryAnimalIdentityEvidence';
+            verifier: string;
+            time: string;
+            content_type: string;
+            digest: Readonly<{
+                alg: 'sha3-384';
+                value: string;
+            }>;
+        }>,
+        Readonly<{
+            type: 'AnimalControllerRelationshipEvidence';
+            relationship: VeterinaryAnimalControllerRelationship;
+            verifier: string;
+            time: string;
+            content_type: string;
+            digest: Readonly<{
+                alg: 'sha3-384';
+                value: string;
+            }>;
+        }>
+    ];
+    credentialStatus: Readonly<{
+        id: string;
+        type: 'SimpleCredentialStatus2026';
+    }>;
+    proof?: unknown;
+}>;
+export type VeterinaryAnimalIdentityAssuranceInput = Readonly<{
+    credentialId: string;
+    issuerDid: string;
+    veterinarianOrganizationId: string;
+    veterinarianRole: 'ISCO-08|2250';
+    holderDid: string;
+    validFrom: string;
+    validUntil: string;
+    animal: Readonly<{
+        id: string;
+        name: string;
+        speciesTaxonomyId: string;
+        identifier: Readonly<{
+            system: string;
+            value: string;
+        }>;
+    }>;
+    controller: Readonly<{
+        id: string;
+        legalName: string;
+        identifier: Readonly<{
+            type: string;
+            value: string;
+            country: string;
+        }>;
+    }>;
+    relationship: VeterinaryAnimalControllerRelationship;
+    evidence: Readonly<{
+        animalDocument: VeterinaryIdentityDocumentDigest;
+        controllerDocument: VeterinaryIdentityDocumentDigest;
+        relationshipDocument: VeterinaryIdentityDocumentDigest;
+        checkedAt: string;
+    }>;
+}>;
+/**
+ * Builds the unsigned W3C VC 2.0 payload attested by a veterinarian.
+ *
+ * OpenID Identity Assurance `verified_claims` is deliberately scoped to the
+ * natural person. Animal identity and the owner/caregiver relationship use
+ * separate veterinary evidence entries. All physical files are hash-only.
+ */
+export declare function buildVeterinaryAnimalIdentityAssuranceCredential(input: VeterinaryAnimalIdentityAssuranceInput): VeterinaryAnimalIdentityAssuranceCredential;
+/** Validates the governed credential shape before wallet storage or presentation. */
+export declare function parseVeterinaryAnimalIdentityAssuranceCredential(value: unknown): VeterinaryAnimalIdentityAssuranceCredential;
+/** Builds the bounded OpenID4VP 1.0 request used by airline, police and insurer verifiers. */
+export declare function buildVeterinaryAnimalIdentityOpenId4VpRequest(input: Readonly<{
+    clientId: string;
+    responseUri: string;
+    nonce: string;
+    state: string;
+    animalId: string;
+}>): Readonly<{
+    client_id: string;
+    response_uri: string;
+    response_type: "vp_token";
+    response_mode: "direct_post";
+    nonce: string;
+    state: string;
+    presentation_definition: Readonly<{
+        id: `vetchain-animal-identity-${string}`;
+        input_descriptors: readonly Readonly<{
+            id: "veterinary-animal-identity-assurance";
+            format: Readonly<{
+                jwt_vc_json: Readonly<{
+                    alg: readonly string[];
+                }>;
+            }>;
+            constraints: Readonly<{
+                fields: readonly Readonly<{
+                    path: readonly string[];
+                    filter: Readonly<{
+                        type: "string";
+                        const: string;
+                    }>;
+                }>[];
+            }>;
+        }>[];
+    }>;
+}>;

package/dist/animal-identity-assurance.js

@@ -0,0 +1,231 @@
+export const VeterinaryAnimalIdentityCredentialTypes = Object.freeze({
+    Assurance: 'VeterinaryAnimalIdentityAssuranceCredential',
+});
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function firstRecord(value) {
+    return Array.isArray(value) ? value.map(record).find(Boolean) : undefined;
+}
+function required(value, error) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    if (!text)
+        throw new TypeError(error);
+    return text;
+}
+function did(value, error) {
+    const text = required(value, error);
+    if (!text.startsWith('did:'))
+        throw new TypeError(error);
+    return text;
+}
+function instant(value, error) {
+    const text = required(value, error);
+    if (!Number.isFinite(Date.parse(text)))
+        throw new TypeError(error);
+    return text;
+}
+function digest(value, error) {
+    const contentType = required(value?.contentType, error);
+    if (!['application/pdf', 'image/jpeg', 'image/png'].includes(contentType))
+        throw new TypeError(error);
+    return Object.freeze({
+        contentType: contentType,
+        sha3_384: required(value?.sha3_384, error),
+    });
+}
+/**
+ * Builds the unsigned W3C VC 2.0 payload attested by a veterinarian.
+ *
+ * OpenID Identity Assurance `verified_claims` is deliberately scoped to the
+ * natural person. Animal identity and the owner/caregiver relationship use
+ * separate veterinary evidence entries. All physical files are hash-only.
+ */
+export function buildVeterinaryAnimalIdentityAssuranceCredential(input) {
+    const credentialId = required(input.credentialId, 'animal_identity_credential_id_required');
+    const issuerDid = did(input.issuerDid, 'animal_identity_credential_issuer_invalid');
+    const holderDid = did(input.holderDid, 'animal_identity_credential_holder_invalid');
+    const controllerId = did(input.controller?.id, 'animal_identity_controller_id_invalid');
+    if (holderDid !== controllerId)
+        throw new TypeError('holder_controller_identity_mismatch');
+    const animalId = did(input.animal?.id, 'animal_identity_subject_invalid');
+    const validFrom = instant(input.validFrom, 'animal_identity_credential_valid_from_invalid');
+    const validUntil = instant(input.validUntil, 'animal_identity_credential_valid_until_invalid');
+    if (Date.parse(validFrom) > Date.parse(validUntil))
+        throw new TypeError('animal_identity_credential_validity_invalid');
+    if (input.relationship !== 'owner' && input.relationship !== 'caregiver') {
+        throw new TypeError('animal_controller_relationship_invalid');
+    }
+    if (input.veterinarianRole !== 'ISCO-08|2250')
+        throw new TypeError('veterinarian_role_invalid');
+    const organization = required(input.veterinarianOrganizationId, 'veterinarian_organization_required');
+    const checkedAt = instant(input.evidence?.checkedAt, 'animal_identity_evidence_time_invalid');
+    const animalDocument = digest(input.evidence?.animalDocument, 'animal_identity_evidence_digest_required');
+    const controllerDocument = digest(input.evidence?.controllerDocument, 'controller_identity_evidence_digest_required');
+    const relationshipDocument = digest(input.evidence?.relationshipDocument, 'relationship_evidence_digest_required');
+    const statusId = `${credentialId}#status`;
+    return Object.freeze({
+        '@context': Object.freeze(['https://www.w3.org/ns/credentials/v2', 'https://schema.org']),
+        id: credentialId,
+        type: Object.freeze(['VerifiableCredential', VeterinaryAnimalIdentityCredentialTypes.Assurance]),
+        issuer: issuerDid,
+        validFrom,
+        validUntil,
+        credentialSubject: Object.freeze({
+            id: holderDid,
+            '@type': 'Person',
+            holdsAnimalIdentity: Object.freeze({
+                id: animalId,
+                '@type': 'Animal',
+                name: required(input.animal?.name, 'animal_identity_name_required'),
+                species: Object.freeze({
+                    '@type': 'Taxon',
+                    taxonRank: 'species',
+                    identifier: required(input.animal?.speciesTaxonomyId, 'animal_identity_species_required'),
+                }),
+                identifier: Object.freeze({
+                    '@type': 'PropertyValue',
+                    propertyID: required(input.animal?.identifier?.system, 'animal_identity_identifier_system_required'),
+                    value: required(input.animal?.identifier?.value, 'animal_identity_identifier_value_required'),
+                }),
+            }),
+            relationshipToAnimal: input.relationship,
+            verified_claims: Object.freeze({
+                verification: Object.freeze({
+                    trust_framework: 'veterinarian_in_person_document_check',
+                    time: checkedAt,
+                    verification_process: credentialId,
+                    evidence: Object.freeze([Object.freeze({
+                            type: 'document',
+                            method: 'physical_in_person_check',
+                            verifier: Object.freeze({ organization, professional: issuerDid, role: input.veterinarianRole }),
+                            time: checkedAt,
+                            check_details: Object.freeze([Object.freeze({ check_method: 'physical_in_person_check', time: checkedAt })]),
+                            attachments: Object.freeze({
+                                content_type: controllerDocument.contentType,
+                                digest: Object.freeze({ alg: 'sha3-384', value: controllerDocument.sha3_384 }),
+                            }),
+                        })]),
+                }),
+                claims: Object.freeze({
+                    name: required(input.controller?.legalName, 'controller_identity_name_required'),
+                    identifier: Object.freeze({
+                        type: required(input.controller?.identifier?.type, 'controller_identity_identifier_type_required'),
+                        value: required(input.controller?.identifier?.value, 'controller_identity_identifier_value_required'),
+                        country: required(input.controller?.identifier?.country, 'controller_identity_identifier_country_required').toUpperCase(),
+                    }),
+                }),
+            }),
+        }),
+        evidence: Object.freeze([
+            Object.freeze({
+                type: 'VeterinaryAnimalIdentityEvidence',
+                verifier: issuerDid,
+                time: checkedAt,
+                content_type: animalDocument.contentType,
+                digest: Object.freeze({ alg: 'sha3-384', value: animalDocument.sha3_384 }),
+            }),
+            Object.freeze({
+                type: 'AnimalControllerRelationshipEvidence',
+                relationship: input.relationship,
+                verifier: issuerDid,
+                time: checkedAt,
+                content_type: relationshipDocument.contentType,
+                digest: Object.freeze({ alg: 'sha3-384', value: relationshipDocument.sha3_384 }),
+            }),
+        ]),
+        credentialStatus: Object.freeze({ id: statusId, type: 'SimpleCredentialStatus2026' }),
+    });
+}
+/** Validates the governed credential shape before wallet storage or presentation. */
+export function parseVeterinaryAnimalIdentityAssuranceCredential(value) {
+    const credential = record(value);
+    const subject = record(credential?.credentialSubject);
+    const animal = record(subject?.holdsAnimalIdentity);
+    const humanEvidence = firstRecord(record(record(subject?.verified_claims)?.verification)?.evidence);
+    const humanVerifier = record(humanEvidence?.verifier);
+    const types = Array.isArray(credential?.type) ? credential.type : [];
+    if (!types.includes('VerifiableCredential') || !types.includes(VeterinaryAnimalIdentityCredentialTypes.Assurance)) {
+        throw new TypeError('animal_identity_credential_type_invalid');
+    }
+    const rebuilt = buildVeterinaryAnimalIdentityAssuranceCredential({
+        credentialId: required(credential?.id, 'animal_identity_credential_id_required'),
+        issuerDid: required(credential?.issuer, 'animal_identity_credential_issuer_invalid'),
+        veterinarianOrganizationId: required(humanVerifier?.organization, 'veterinarian_organization_required'),
+        veterinarianRole: 'ISCO-08|2250',
+        holderDid: required(subject?.id, 'animal_identity_credential_holder_invalid'),
+        validFrom: required(credential?.validFrom, 'animal_identity_credential_valid_from_invalid'),
+        validUntil: required(credential?.validUntil, 'animal_identity_credential_valid_until_invalid'),
+        animal: {
+            id: required(animal?.id, 'animal_identity_subject_invalid'),
+            name: required(animal?.name, 'animal_identity_name_required'),
+            speciesTaxonomyId: required(record(animal?.species)?.identifier, 'animal_identity_species_required'),
+            identifier: {
+                system: required(record(animal?.identifier)?.propertyID, 'animal_identity_identifier_system_required'),
+                value: required(record(animal?.identifier)?.value, 'animal_identity_identifier_value_required'),
+            },
+        },
+        controller: {
+            id: required(subject?.id, 'animal_identity_controller_id_invalid'),
+            legalName: required(record(record(subject?.verified_claims)?.claims)?.name, 'controller_identity_name_required'),
+            identifier: record(record(record(subject?.verified_claims)?.claims)?.identifier),
+        },
+        relationship: subject?.relationshipToAnimal,
+        evidence: parseCredentialEvidence(credential, subject),
+    });
+    return Object.freeze({ ...rebuilt, ...(credential?.proof !== undefined ? { proof: credential.proof } : {}) });
+}
+function parseCredentialEvidence(credential, subject) {
+    const evidence = Array.isArray(credential.evidence) ? credential.evidence.map(record).filter(Boolean) : [];
+    const animal = evidence.find(item => item.type === 'VeterinaryAnimalIdentityEvidence');
+    const relationship = evidence.find(item => item.type === 'AnimalControllerRelationshipEvidence');
+    const human = firstRecord(record(record(subject.verified_claims)?.verification)?.evidence);
+    const humanAttachment = record(human?.attachments);
+    const humanDigest = record(humanAttachment?.digest);
+    const animalDigest = record(animal?.digest);
+    const relationshipDigest = record(relationship?.digest);
+    return {
+        animalDocument: {
+            contentType: animal?.content_type,
+            sha3_384: required(animalDigest?.value, 'animal_identity_evidence_digest_required'),
+        },
+        controllerDocument: {
+            contentType: humanAttachment?.content_type,
+            sha3_384: required(humanDigest?.value, 'controller_identity_evidence_digest_required'),
+        },
+        relationshipDocument: {
+            contentType: relationship?.content_type,
+            sha3_384: required(relationshipDigest?.value, 'relationship_evidence_digest_required'),
+        },
+        checkedAt: required(animal?.time, 'animal_identity_evidence_time_invalid'),
+    };
+}
+/** Builds the bounded OpenID4VP 1.0 request used by airline, police and insurer verifiers. */
+export function buildVeterinaryAnimalIdentityOpenId4VpRequest(input) {
+    const clientId = required(input.clientId, 'animal_identity_verifier_client_id_required');
+    const responseUri = required(input.responseUri, 'animal_identity_verifier_response_uri_required');
+    const nonce = required(input.nonce, 'animal_identity_presentation_nonce_required');
+    const state = required(input.state, 'animal_identity_presentation_state_required');
+    const animalId = did(input.animalId, 'animal_identity_subject_invalid');
+    return Object.freeze({
+        client_id: clientId,
+        response_uri: responseUri,
+        response_type: 'vp_token',
+        response_mode: 'direct_post',
+        nonce,
+        state,
+        presentation_definition: Object.freeze({
+            id: `vetchain-animal-identity-${state}`,
+            input_descriptors: Object.freeze([Object.freeze({
+                    id: 'veterinary-animal-identity-assurance',
+                    format: Object.freeze({ jwt_vc_json: Object.freeze({ alg: Object.freeze(['ES256', 'ML-DSA-65']) }) }),
+                    constraints: Object.freeze({
+                        fields: Object.freeze([
+                            Object.freeze({ path: Object.freeze(['$.type']), filter: Object.freeze({ type: 'string', const: VeterinaryAnimalIdentityCredentialTypes.Assurance }) }),
+                            Object.freeze({ path: Object.freeze(['$.credentialSubject.holdsAnimalIdentity.id']), filter: Object.freeze({ type: 'string', const: animalId }) }),
+                        ]),
+                    }),
+                })]),
+        }),
+    });
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './animal-card.js';
+export * from './animal-identity-assurance.js';
 export * from './animal-behavior.js';
 export * from './assistant.js';
 export * from './communication.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './animal-card.js';
+export * from './animal-identity-assurance.js';
 export * from './animal-behavior.js';
 export * from './assistant.js';
 export * from './communication.js';

package/dist/place-service-directory.d.ts

@@ -197,9 +197,9 @@ export declare const DataspaceProtocol2025: Readonly<{
 /**
  * Builds the claims-only public department Organization.
  *
- * One department is one Schema.org/FHIR Organization and owns one stable
- * HealthcareService projection whose id is the same department id. Offered
- * Services remain separate directory records linked through providerIdentifier.
+ * One department is one Schema.org/FHIR Organization. Each offered Service
+ * remains a separate directory record and owns its own HealthcareService
+ * projection through providerIdentifier.
  */
 export declare function buildDepartmentDirectoryResource(input: DepartmentDirectoryInput): DirectoryResource;
 /** Builds the claims-only public Place authored by an organization. */
@@ -239,49 +239,14 @@ export declare function projectDepartmentToFhirR5Organization(department: Direct
     name: string;
 }>;
 /**
- * Projects all offered Services of one department into its single stable
- * HealthcareService. The Services supply types; the department supplies the
- * provider identity and allowed Locations.
+ * @deprecated Aggregate department HealthcareService projection is forbidden.
+ * Project each offered Service independently with
+ * projectServiceToFhirR5HealthcareService(...).
  */
 export declare function projectDepartmentToFhirR5HealthcareService(department: DirectoryResource | DirectoryFlatClaimsResource, input: Readonly<{
     services: readonly (DirectoryResource | DirectoryFlatClaimsResource)[];
     places: readonly (DirectoryResource | DirectoryFlatClaimsResource)[];
-}>): Readonly<{
-    meta: {
-        claims: {
-            'HealthcareService.service-category'?: string[] | undefined;
-            'HealthcareService.identifier': string;
-            'HealthcareService.organization': string;
-            'HealthcareService.name': string | undefined;
-            'HealthcareService.location': string[];
-            'HealthcareService.service-type': string[];
-        };
-    };
-    photo?: {
-        url: string;
-    } | undefined;
-    resourceType: "HealthcareService";
-    id: string;
-    active: true;
-    providedBy: {
-        reference: string;
-    };
-    name: string | undefined;
-    comment: string | undefined;
-    category: {
-        coding: {
-            code: string;
-        }[];
-    }[];
-    type: {
-        coding: {
-            code: string;
-        }[];
-    }[];
-    location: {
-        reference: string;
-    }[];
-}>;
+}>): void;
 /** Explicitly projects one neutral Place to native FHIR R5 Location for export or interop. */
 export declare function projectPlaceToFhirR5Location(place: DirectoryResource | DirectoryFlatClaimsResource): Readonly<{
     resourceType: "Location";

package/dist/place-service-directory.js

@@ -169,9 +169,9 @@ function encodeSpecialOpeningHours(value) {
 /**
  * Builds the claims-only public department Organization.
  *
- * One department is one Schema.org/FHIR Organization and owns one stable
- * HealthcareService projection whose id is the same department id. Offered
- * Services remain separate directory records linked through providerIdentifier.
+ * One department is one Schema.org/FHIR Organization. Each offered Service
+ * remains a separate directory record and owns its own HealthcareService
+ * projection through providerIdentifier.
  */
 export function buildDepartmentDirectoryResource(input) {
     const id = required(input.id, 'department_id_required');
@@ -421,54 +421,14 @@ export function projectDepartmentToFhirR5Organization(department) {
     });
 }
 /**
- * Projects all offered Services of one department into its single stable
- * HealthcareService. The Services supply types; the department supplies the
- * provider identity and allowed Locations.
+ * @deprecated Aggregate department HealthcareService projection is forbidden.
+ * Project each offered Service independently with
+ * projectServiceToFhirR5HealthcareService(...).
  */
 export function projectDepartmentToFhirR5HealthcareService(department, input) {
-    if (department.resourceType !== 'Organization')
-        throw new TypeError('department_resource_required');
-    const departmentLocations = values(department, ClaimsDirectoryOrganizationSchemaorg.locationIdentifier);
-    const places = departmentLocations.map(identifier => {
-        const place = input.places.find(candidate => candidate.resourceType === 'Place' && candidate.id === identifier);
-        if (!place)
-            throw new TypeError('department_place_not_found');
-        return place;
-    });
-    const services = input.services.filter(service => {
-        if (service.resourceType !== 'Service')
-            throw new TypeError('service_resource_required');
-        return first(service, ClaimsDirectoryServiceSchemaorg.providerIdentifier) === department.id;
-    });
-    if (!services.length)
-        throw new TypeError('department_service_required');
-    for (const service of services) {
-        if (values(service, ClaimsDirectoryServiceSchemaorg.placeIdentifier).some(identifier => !departmentLocations.includes(identifier))) {
-            throw new TypeError('department_service_place_invalid');
-        }
-    }
-    const serviceTypes = [...new Set(services.flatMap(service => values(service, ClaimsDirectoryServiceSchemaorg.serviceType)))];
-    const categories = [...new Set(services.flatMap(service => values(service, ClaimsDirectoryServiceSchemaorg.category)))];
-    const concept = (code) => ({ coding: [{ code }] });
-    const photoUrl = first(department, ClaimsDirectoryOrganizationSchemaorg.logoContentUrl)
-        || places.map(place => first(place, ClaimsPlaceSchemaorg.photoContentUrl)).find(Boolean);
-    return Object.freeze({
-        resourceType: 'HealthcareService', id: department.id, active: true,
-        providedBy: { reference: `Organization/${department.id}` },
-        name: first(department, ClaimsDirectoryOrganizationSchemaorg.name),
-        comment: first(department, ClaimsDirectoryOrganizationSchemaorg.description),
-        category: categories.map(concept), type: serviceTypes.map(concept),
-        location: places.map(place => ({ reference: `Location/${place.id}` })),
-        ...(photoUrl ? { photo: { url: photoUrl } } : {}),
-        meta: { claims: {
-                'HealthcareService.identifier': department.id,
-                'HealthcareService.organization': `Organization/${department.id}`,
-                'HealthcareService.name': first(department, ClaimsDirectoryOrganizationSchemaorg.name),
-                'HealthcareService.location': places.map(place => `Location/${place.id}`),
-                'HealthcareService.service-type': serviceTypes,
-                ...(categories.length ? { 'HealthcareService.service-category': categories } : {}),
-            } },
-    });
+    void department;
+    void input;
+    throw new TypeError('department_aggregate_healthcare_service_forbidden');
 }
 /** Explicitly projects one neutral Place to native FHIR R5 Location for export or interop. */
 export function projectPlaceToFhirR5Location(place) {
@@ -519,7 +479,8 @@ export function projectServiceToFhirR5HealthcareService(service, input) {
     });
     const serviceTypes = values(service, ClaimsDirectoryServiceSchemaorg.serviceType);
     const categories = values(service, ClaimsDirectoryServiceSchemaorg.category);
-    const organization = required(first(service, ClaimsDirectoryServiceSchemaorg.providerIdentifier), 'service_organization_required');
+    const rawOrganization = required(first(service, ClaimsDirectoryServiceSchemaorg.providerIdentifier), 'service_organization_required');
+    const organization = rawOrganization.startsWith('Organization/') ? rawOrganization : `Organization/${rawOrganization}`;
     const photoUrl = places.map(place => first(place, ClaimsPlaceSchemaorg.photoContentUrl)).find(Boolean);
     const concept = (code) => ({ coding: [{ code }] });
     return Object.freeze({

package/dist/scheduling.d.ts

@@ -1,3 +1,4 @@
+import { buildSchedulableLocationFlatResource } from 'fhir-data-utils-ts';
 /** FHIR R5 Slot statuses accepted by reusable scheduling. */
 export declare const SlotStatuses: Readonly<{
     readonly Busy: "busy";
@@ -28,12 +29,12 @@ export declare const AppointmentStatuses: Readonly<{
     readonly Waitlist: "waitlist";
 }>;
 /** Official FHIR R5 Slot resource-specific SearchParameter codes. */
-export declare const SlotSearchParameters: readonly ["appointment-type", "identifier", "schedule", "service-category", "service-type", "service-type-reference", "specialty", "start", "status"];
+export declare const SlotSearchParameters: readonly string[];
 /** Official FHIR R5 SearchParameter codes used by reusable scheduling. */
 export declare const SchedulingSearchParameterCatalog: Readonly<{
     readonly Location: readonly string[];
     readonly Schedule: readonly string[];
-    readonly Slot: readonly ["appointment-type", "identifier", "schedule", "service-category", "service-type", "service-type-reference", "specialty", "start", "status"];
+    readonly Slot: readonly string[];
     readonly Appointment: readonly string[];
     readonly AppointmentResponse: readonly string[];
 }>;
@@ -47,7 +48,7 @@ export type SchedulingFlatClaimsResource = Readonly<Record<string, unknown> & {
         claims: Readonly<Record<string, readonly string[]>>;
     }>;
 }>;
-/** Validates native FHIR scheduling data and normalizes indexed SearchParameter claims to strings. */
+/** Rejects nested native FHIR and normalizes governed flat claims to strings. */
 export declare function normalizeSchedulingFlatClaimsResource(input: unknown): SchedulingFlatClaimsResource;
 export type ClaimsFirstResource = Readonly<Record<string, unknown> & {
     resourceType: string;
@@ -68,15 +69,18 @@ export declare function buildLocationResource(input: Readonly<{
     characteristicCodes?: readonly string[];
     photoUrl?: string;
 }>): ClaimsFirstResource;
-/** Builds the claims-first FHIR R5 Schedule joining one practitioner and consultation Location. */
+/** Builds one service-specific Schedule through the neutral FHIR claims graph. */
 export declare function buildScheduleResource(input: Readonly<{
-    id: string;
+    scheduleUrn: string;
     name: string;
-    practitionerReference: string;
-    locationReference: string;
+    healthcareServiceReference: string;
+    resourceActorReferences: readonly string[];
+    serviceType: string;
     planningHorizonStart: string;
     planningHorizonEnd: string;
 }>): ClaimsFirstResource;
+/** Builds one independently reservable child Location; equipment remains Device. */
+export declare const buildSchedulableLocationResource: typeof buildSchedulableLocationFlatResource;
 export type AvailabilityPeriod = Readonly<{
     daysOfWeek: readonly number[];
     startTime: string;
@@ -101,11 +105,13 @@ export type ExpandedSlot = Readonly<{
     locationReference: string;
     resource: ClaimsFirstResource;
 }>;
-/** Produces the stable Schedule id for one practitioner/location availability stream. */
-export declare function scheduleIdForLocation(baseScheduleId: string, locationReference: string): string;
 /** Expands bounded weekly availability into claims-first Slots, applying recurring restrictions or expansions. */
 export declare function expandAvailability(input: Readonly<{
-    scheduleId: string;
+    /** One service-owned Schedule URN for each independently reservable Location. */
+    scheduleUrnsByLocation: Readonly<Record<string, string>>;
+    healthcareServiceReference: string;
+    serviceType: string;
+    resourceActorReferencesByLocation: Readonly<Record<string, readonly string[]>>;
     startDate: string;
     endDate: string;
     timeZone: string;
@@ -161,7 +167,7 @@ export declare function buildAppointmentNotificationResource(input: Readonly<{
     reason: string;
 }>): ClaimsFirstResource;
 /** @deprecated Use {@link SlotSearchParameters}. */
-export declare const VeterinarySlotSearchParameters: readonly ["appointment-type", "identifier", "schedule", "service-category", "service-type", "service-type-reference", "specialty", "start", "status"];
+export declare const VeterinarySlotSearchParameters: readonly string[];
 /** @deprecated Use {@link SchedulingFlatClaimCatalog}. */
 export declare const VeterinarySchedulingFlatClaimCatalog: Readonly<Record<"Appointment" | "AppointmentResponse" | "Location" | "Schedule" | "Slot", readonly string[]>>;
 /** @deprecated Use {@link SchedulingResourceType}. */

package/dist/scheduling.js

@@ -1,3 +1,5 @@
+import { ScheduleR5SearchParameterCatalog, SlotR5SearchParameterCatalog, buildSchedulableLocationFlatResource, buildServiceScheduleFlatGraph, } from 'fhir-data-utils-ts';
+import { buildScheduleSlotIdentity, deriveFhirResourceIdFromUrn, } from 'sos-data-utils-ts/organization-scoped-resource-identity';
 /** FHIR R5 Slot statuses accepted by reusable scheduling. */
 export const SlotStatuses = Object.freeze({ Busy: 'busy', Free: 'free', BusyUnavailable: 'busy-unavailable', BusyTentative: 'busy-tentative', EnteredInError: 'entered-in-error' });
 /** FHIR R5 AppointmentResponse participant statuses. */
@@ -8,11 +10,11 @@ export const AppointmentStatuses = Object.freeze({
     Cancelled: 'cancelled', NoShow: 'noshow', EnteredInError: 'entered-in-error', CheckedIn: 'checked-in', Waitlist: 'waitlist',
 });
 /** Official FHIR R5 Slot resource-specific SearchParameter codes. */
-export const SlotSearchParameters = Object.freeze(['appointment-type', 'identifier', 'schedule', 'service-category', 'service-type', 'service-type-reference', 'specialty', 'start', 'status']);
+export const SlotSearchParameters = Object.freeze(SlotR5SearchParameterCatalog.map(definition => definition.claim.slice('Slot.'.length)));
 /** Official FHIR R5 SearchParameter codes used by reusable scheduling. */
 export const SchedulingSearchParameterCatalog = Object.freeze({
     Location: Object.freeze(['characteristic', 'identifier', 'name', 'near', 'organization', 'status', 'type']),
-    Schedule: Object.freeze(['active', 'actor', 'date', 'identifier', 'name', 'service-category', 'service-type', 'specialty']),
+    Schedule: Object.freeze(ScheduleR5SearchParameterCatalog.map(definition => definition.claim.slice('Schedule.'.length))),
     Slot: SlotSearchParameters,
     Appointment: Object.freeze(['actor', 'appointment-type', 'based-on', 'date', 'identifier', 'location', 'part-status', 'patient', 'practitioner', 'reason-code', 'reason-reference', 'service-category', 'service-type', 'slot', 'specialty', 'status', 'subject', 'supporting-info']),
     AppointmentResponse: Object.freeze(['_lastUpdated', 'actor', 'appointment', 'group', 'identifier', 'location', 'part-status', 'patient', 'practitioner']),
@@ -22,17 +24,12 @@ export const SchedulingFlatClaimCatalog = Object.freeze(Object.fromEntries(Objec
     resourceType,
     Object.freeze([
         ...parameters.map(parameter => `${resourceType}.${parameter}`),
+        ...(resourceType === 'Schedule' ? ['Schedule.planning-horizon-start', 'Schedule.planning-horizon-end'] : []),
+        ...(resourceType === 'Slot' ? ['Slot.end'] : []),
         ...(resourceType === 'Appointment' ? ['Appointment.user-selected'] : []),
     ]),
 ])));
-const nativeFieldsByResource = Object.freeze({
-    Location: new Set(['identifier', 'status', 'mode', 'name', 'description', 'type', 'telecom', 'address', 'physicalType', 'position', 'managingOrganization', 'characteristic', 'contained']),
-    Schedule: new Set(['identifier', 'active', 'serviceCategory', 'serviceType', 'specialty', 'name', 'actor', 'planningHorizon', 'comment']),
-    Slot: new Set(['identifier', 'serviceCategory', 'serviceType', 'specialty', 'appointmentType', 'schedule', 'status', 'start', 'end', 'overbooked', 'comment']),
-    Appointment: new Set(['identifier', 'status', 'serviceCategory', 'serviceType', 'specialty', 'appointmentType', 'reason', 'description', 'start', 'end', 'slot', 'participant', 'subject', 'note', 'supportingInformation', 'contained']),
-    AppointmentResponse: new Set(['identifier', 'appointment', 'proposedNewTime', 'start', 'end', 'participantType', 'actor', 'participantStatus', 'comment', 'recurring', 'occurrenceDate', 'recurrenceId', 'contained']),
-});
-/** Validates native FHIR scheduling data and normalizes indexed SearchParameter claims to strings. */
+/** Rejects nested native FHIR and normalizes governed flat claims to strings. */
 export function normalizeSchedulingFlatClaimsResource(input) {
     if (!input || typeof input !== 'object' || Array.isArray(input))
         throw new TypeError('scheduling_flat_resource_invalid');
@@ -40,7 +37,7 @@ export function normalizeSchedulingFlatClaimsResource(input) {
     if (typeof value.resourceType !== 'string' || !(value.resourceType in SchedulingFlatClaimCatalog))
         throw new TypeError('scheduling_flat_resource_invalid');
     const resourceType = value.resourceType;
-    if (Object.keys(value).some(key => !['resourceType', 'id', 'meta'].includes(key) && !nativeFieldsByResource[resourceType].has(key)))
+    if (Object.keys(value).some(key => !['resourceType', 'id', 'meta'].includes(key)))
         throw new TypeError('scheduling_flat_resource_invalid');
     const id = required(String(value.id || ''), 'scheduling_flat_resource_invalid');
     if (!/^[A-Za-z0-9\-.]{1,64}$/.test(id))
@@ -90,31 +87,25 @@ export function buildLocationResource(input) {
         'Location.near': `${input.latitude}|${input.longitude}`,
         'Location.organization': organizationReference,
         ...(characteristicCodes.length ? { 'Location.characteristic': characteristicCodes } : {}),
-    }, {
-        identifier: [{ value: input.id }], status: 'active', mode: 'instance', name,
-        ...(input.description ? { description: input.description.trim() } : {}),
-        position: { latitude: input.latitude, longitude: input.longitude, ...(input.altitude === undefined ? {} : { altitude: input.altitude }) },
-        managingOrganization: { reference: organizationReference },
-        ...(characteristicCodes.length ? { characteristic: characteristicCodes.map(code => ({ coding: [{ code }] })) } : {}),
-        ...(input.photoUrl ? { contained: [{ resourceType: 'DocumentReference', id: 'location-photo', status: 'current', content: [{ attachment: { url: input.photoUrl } }] }] } : {}),
     });
 }
-/** Builds the claims-first FHIR R5 Schedule joining one practitioner and consultation Location. */
+/** Builds one service-specific Schedule through the neutral FHIR claims graph. */
 export function buildScheduleResource(input) {
-    const start = assertDate(input.planningHorizonStart);
-    const end = assertDate(input.planningHorizonEnd);
-    if (start > end)
-        throw new Error('schedule_horizon_invalid');
-    const name = required(input.name, 'schedule_name_required');
-    const actors = Object.freeze([required(input.practitionerReference, 'schedule_practitioner_required'), required(input.locationReference, 'schedule_location_required')]);
-    return claimsResource('Schedule', input.id, {
-        'Schedule.identifier': input.id, 'Schedule.active': true, 'Schedule.name': name,
-        'Schedule.actor': actors, 'Schedule.date': Object.freeze([start, end]),
-    }, {
-        identifier: [{ value: input.id }], active: true, name,
-        actor: actors.map(reference => ({ reference })), planningHorizon: { start, end },
+    const id = deriveFhirResourceIdFromUrn(input.scheduleUrn);
+    const graph = buildServiceScheduleFlatGraph({
+        scheduleId: id,
+        scheduleIdentifier: input.scheduleUrn,
+        name: input.name,
+        healthcareServiceReference: input.healthcareServiceReference,
+        resourceActorReferences: input.resourceActorReferences,
+        serviceType: input.serviceType,
+        planningHorizon: { start: input.planningHorizonStart, end: input.planningHorizonEnd },
+        slots: [],
     });
+    return graph[0];
 }
+/** Builds one independently reservable child Location; equipment remains Device. */
+export const buildSchedulableLocationResource = buildSchedulableLocationFlatResource;
 const minutes = (value) => { const [hour, minute] = assertTime(value).split(':').map(Number); return hour * 60 + minute; };
 const timeFromMinutes = (value) => `${String(Math.floor(value / 60)).padStart(2, '0')}:${String(value % 60).padStart(2, '0')}`;
 const dates = (start, end) => { const result = []; const cursor = new Date(`${start}T00:00:00Z`); const last = new Date(`${end}T00:00:00Z`); while (cursor <= last) {
@@ -140,12 +131,6 @@ const matchesExceptionDate = (date, recurrence) => { const [, , day] = dateParts
 const validateRange = (startTime, endTime, code) => { const start = minutes(startTime); const end = minutes(endTime); if (start >= end)
     throw new Error(code); return [start, end]; };
 const slotKey = (location, date, start, end) => `${location}|${date}|${start}|${end}`;
-/** Produces the stable Schedule id for one practitioner/location availability stream. */
-export function scheduleIdForLocation(baseScheduleId, locationReference) {
-    const base = required(baseScheduleId, 'schedule_id_required');
-    const locationId = required(locationReference, 'availability_location_required').split('/').at(-1);
-    return `${base}-${locationId}`;
-}
 /** Expands bounded weekly availability into claims-first Slots, applying recurring restrictions or expansions. */
 export function expandAvailability(input) {
     const startDate = assertDate(input.startDate);
@@ -201,11 +186,33 @@ export function expandAvailability(input) {
     return Object.freeze([...base.values()].sort((left, right) => slotKey(left.locationReference, left.localDate, left.localStart, left.localEnd).localeCompare(slotKey(right.locationReference, right.localDate, right.localStart, right.localEnd))).map(slot => {
         const start = zonedInstant(slot.localDate, slot.localStart, input.timeZone);
         const end = zonedInstant(slot.localDate, slot.localEnd, input.timeZone);
-        const id = `${input.scheduleId}-${slot.localDate}-${slot.localStart.replace(':', '')}-${slot.locationReference.split('/').at(-1)}`;
-        const scheduleReference = `Schedule/${scheduleIdForLocation(input.scheduleId, slot.locationReference)}`;
-        return Object.freeze({ ...slot, resource: claimsResource('Slot', id, {
-                'Slot.identifier': id, 'Slot.schedule': scheduleReference, 'Slot.status': SlotStatuses.Free, 'Slot.start': start,
-            }, { identifier: [{ value: id }], schedule: { reference: scheduleReference }, status: SlotStatuses.Free, start, end }) });
+        const scheduleUrn = required(input.scheduleUrnsByLocation[slot.locationReference] || '', 'availability_schedule_urn_required');
+        const scheduleResourceId = deriveFhirResourceIdFromUrn(scheduleUrn);
+        const slotIdentity = buildScheduleSlotIdentity({ scheduleUrn, start, end });
+        const scheduleReference = `Schedule/${scheduleResourceId}`;
+        const actors = input.resourceActorReferencesByLocation[slot.locationReference];
+        if (!actors?.includes(slot.locationReference))
+            throw new Error('availability_resource_actors_required');
+        const graph = buildServiceScheduleFlatGraph({
+            scheduleId: scheduleReference.slice('Schedule/'.length),
+            scheduleIdentifier: scheduleReference,
+            name: scheduleReference,
+            healthcareServiceReference: input.healthcareServiceReference,
+            resourceActorReferences: actors,
+            serviceType: input.serviceType,
+            planningHorizon: {
+                start: zonedInstant(startDate, '00:00', input.timeZone),
+                end: new Date(Date.parse(zonedInstant(endDate, '23:59', input.timeZone)) + 60_000).toISOString(),
+            },
+            slots: [{
+                    slotId: slotIdentity.id,
+                    slotIdentifier: slotIdentity.identifier,
+                    status: SlotStatuses.Free,
+                    start,
+                    end,
+                }],
+        });
+        return Object.freeze({ ...slot, resource: graph[1] });
     }));
 }
 /** Builds a claims-first response that confirms, declines or proposes a new appointment time. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-data-utils-ts",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "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-identity-assurance": {
+      "types": "./dist/animal-identity-assurance.d.ts",
+      "default": "./dist/animal-identity-assurance.js"
+    },
     "./animal-behavior": {
       "types": "./dist/animal-behavior.d.ts",
       "default": "./dist/animal-behavior.js"
@@ -157,10 +161,10 @@
     "typescript": "^5.5.4"
   },
   "dependencies": {
-    "fhir-data-utils-ts": "0.2.4",
+    "fhir-data-utils-ts": "0.6.0",
     "gdc-common-utils-ts": "2.9.12",
     "pako": "^2.2.0",
-    "sos-data-utils-ts": "0.3.7"
+    "sos-data-utils-ts": "0.5.1"
   },
   "engines": {
     "node": ">=20"