vet-data-utils-ts 0.5.20 → 0.5.22

package/README.md

@@ -1,5 +1,25 @@
 # vet-data-utils-ts
 
+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
+services; an insurance organization publishes products in a Schema.org
+`OfferCatalog`. Photos, accessibility, coordinates, address and opening-hours
+specifications remain neutral indexed claims. Native FHIR R5 `Location`,
+`HealthcareService` and `InsurancePlan` are produced only by explicit
+projection helpers. Member-specific FHIR `Coverage` is never a public catalog
+entry. The shared `gdc-*` claim catalog remains unchanged while this profile is
+validated in VetChain.
+
+The customer-facing Schema.org `OfferCatalog` is distinct from the Eclipse
+Dataspace Protocol catalog. `buildDataspaceCatalogAdvertisement(...)` exposes a
+transferable catalog snapshot as a DSP 2025-1 Dataset with an ODRL use Offer;
+`buildDataspaceDataAddress(...)` describes the endpoint only in the negotiated
+transfer flow. The package deliberately has no third-party DSP runtime
+dependency: the Eclipse project publishes the specification and Java TCK/EDC
+implementation, while currently available npm implementations are independent
+projects and are not adopted implicitly.
+
 ## Veterinary immunization credentials
 
 `buildVeterinaryImmunization(...)` creates a FHIR R4 `Immunization` with the

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export * from './index-projection-tags.js';
 export * from './iso-jurisdictions.js';
 export * from './organization-application.js';
 export * from './payment.js';
+export * from './place-service-directory.js';
 export * from './research-study.js';
 export * from './sectors.js';
 export * from './shc.js';

package/dist/index.js

@@ -13,6 +13,7 @@ export * from './index-projection-tags.js';
 export * from './iso-jurisdictions.js';
 export * from './organization-application.js';
 export * from './payment.js';
+export * from './place-service-directory.js';
 export * from './research-study.js';
 export * from './sectors.js';
 export * from './shc.js';

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

@@ -0,0 +1,412 @@
+/** Schema.org flat claims for a persistent, sector-neutral public Place. */
+export declare enum ClaimsPlaceSchemaorg {
+    identifier = "org.schema.Place.identifier",
+    additionalType = "org.schema.Place.additionalType",
+    name = "org.schema.Place.name",
+    description = "org.schema.Place.description",
+    ownerIdentifier = "org.schema.Place.owner.identifier",
+    addressCountry = "org.schema.Place.address.addressCountry",
+    addressRegion = "org.schema.Place.address.addressRegion",
+    addressLocality = "org.schema.Place.address.addressLocality",
+    extendedAddress = "org.schema.Place.address.extendedAddress",
+    postalCode = "org.schema.Place.address.postalCode",
+    streetAddress = "org.schema.Place.address.streetAddress",
+    latitude = "org.schema.Place.geo.latitude",
+    longitude = "org.schema.Place.geo.longitude",
+    elevation = "org.schema.Place.geo.elevation",
+    photoContentUrl = "org.schema.Place.photo.contentUrl",
+    amenityFeature = "org.schema.Place.amenityFeature",
+    publicAccess = "org.schema.Place.publicAccess",
+    openingHoursSpecification = "org.schema.Place.openingHoursSpecification",
+    specialOpeningHoursSpecification = "org.schema.Place.specialOpeningHoursSpecification",
+    userSelected = "Place.user-selected"
+}
+/** Schema.org Service claims needed to join a public service to one or more Places. */
+export declare enum ClaimsDirectoryServiceSchemaorg {
+    identifier = "org.schema.Service.identifier",
+    name = "org.schema.Service.name",
+    description = "org.schema.Service.description",
+    providerIdentifier = "org.schema.Service.provider.identifier",
+    placeIdentifier = "org.schema.Service.availableChannel.serviceLocation.identifier",
+    serviceType = "org.schema.Service.serviceType",
+    category = "org.schema.Service.category",
+    areaServed = "org.schema.Service.areaServed",
+    userSelected = "Service.user-selected"
+}
+/** Schema.org Product claims for an organization's public commercial offering. */
+export declare enum ClaimsProductSchemaorg {
+    identifier = "org.schema.Product.identifier",
+    additionalType = "org.schema.Product.additionalType",
+    name = "org.schema.Product.name",
+    description = "org.schema.Product.description",
+    providerIdentifier = "org.schema.Product.provider.identifier",
+    category = "org.schema.Product.category",
+    areaServed = "org.schema.Product.areaServed",
+    url = "org.schema.Product.url",
+    imageContentUrl = "org.schema.Product.image.contentUrl",
+    availabilityStarts = "org.schema.Product.offers.availabilityStarts",
+    availabilityEnds = "org.schema.Product.offers.availabilityEnds",
+    price = "org.schema.Product.offers.price",
+    priceCurrency = "org.schema.Product.offers.priceCurrency",
+    insuranceStatus = "org.schema.Product.additionalProperty.insuranceStatus",
+    insuranceCoverageType = "org.schema.Product.additionalProperty.insuranceCoverageType",
+    insuranceNetwork = "org.schema.Product.additionalProperty.insuranceNetwork",
+    userSelected = "Product.user-selected"
+}
+/** Product-local allowlist for the experimental Place, Service and Product directory profile. */
+export declare const DirectoryFlatClaimCatalog: Readonly<{
+    readonly Place: readonly ClaimsPlaceSchemaorg[];
+    readonly Service: readonly ClaimsDirectoryServiceSchemaorg[];
+    readonly Product: readonly ClaimsProductSchemaorg[];
+}>;
+export type DirectoryResourceType = keyof typeof DirectoryFlatClaimCatalog;
+export type DirectoryClaimValue = string | number | boolean | readonly string[];
+export type DirectoryResource = Readonly<{
+    resourceType: DirectoryResourceType;
+    id: string;
+    meta: Readonly<{
+        claims: Readonly<Record<string, DirectoryClaimValue>>;
+    }>;
+}>;
+export type DirectoryFlatClaimsResource = Readonly<{
+    resourceType: DirectoryResourceType;
+    id: string;
+    meta: Readonly<{
+        claims: Readonly<Record<string, readonly string[]>>;
+    }>;
+}>;
+export type OpeningHoursInput = Readonly<{
+    daysOfWeek: readonly string[];
+    opens: string;
+    closes: string;
+    validFrom?: string;
+    validThrough?: string;
+}>;
+export type SpecialOpeningHoursInput = Readonly<{
+    validFrom: string;
+    validThrough: string;
+    closed?: boolean;
+    opens?: string;
+    closes?: string;
+}>;
+export type PlaceDirectoryInput = Readonly<{
+    id: string;
+    organizationIdentifier: string;
+    name: string;
+    description?: string;
+    additionalType?: string;
+    address: Readonly<{
+        addressCountry: string;
+        addressRegion?: string;
+        addressLocality?: string;
+        extendedAddress?: string;
+        postalCode: string;
+        streetAddress?: string;
+    }>;
+    position: Readonly<{
+        latitude: number;
+        longitude: number;
+        elevation?: number;
+    }>;
+    photoUrl?: string;
+    accessibilityFeatures?: readonly string[];
+    publicAccess?: boolean;
+    openingHours?: readonly OpeningHoursInput[];
+    specialOpeningHours?: readonly SpecialOpeningHoursInput[];
+    userSelected?: boolean;
+}>;
+export type ServiceDirectoryInput = Readonly<{
+    id: string;
+    organizationIdentifier: string;
+    placeIdentifiers: readonly string[];
+    name: string;
+    description?: string;
+    serviceTypes: readonly string[];
+    categories?: readonly string[];
+    areaServed?: readonly string[];
+    userSelected?: boolean;
+}>;
+export type ProductDirectoryInput = Readonly<{
+    id: string;
+    organizationIdentifier: string;
+    name: string;
+    description?: string;
+    productType: string;
+    categories?: readonly string[];
+    areaServed?: readonly string[];
+    url?: string;
+    imageUrl?: string;
+    availableFrom?: string;
+    availableThrough?: string;
+    price?: number;
+    priceCurrency?: string;
+    insurance?: Readonly<{
+        status: 'draft' | 'active' | 'retired' | 'unknown';
+        coverageTypes: readonly string[];
+        networks?: readonly string[];
+    }>;
+    userSelected?: boolean;
+}>;
+/** Sector-owned offering kind. It drives presentation only and grants no authority. */
+export declare const OrganizationOfferingKinds: Readonly<{
+    readonly 'animal-care': "Service";
+    readonly 'animal-insurance': "Product";
+}>;
+/** Stable Eclipse Dataspace Protocol 2025-1 identifiers, including current editorial errata. */
+export declare const DataspaceProtocol2025: Readonly<{
+    readonly release: "2025-1-err1";
+    readonly context: "https://w3id.org/dspace/2025/1/context.jsonld";
+    readonly httpEndpointType: "https://w3id.org/idsa/v4.1/HTTP";
+}>;
+/** Builds the claims-only public Place authored by an organization. */
+export declare function buildPlaceDirectoryResource(input: PlaceDirectoryInput): DirectoryResource;
+/** Builds a claims-only Schema.org Service joined to its provider and public Places. */
+export declare function buildServiceDirectoryResource(input: ServiceDirectoryInput): DirectoryResource;
+/** Builds a claims-only Schema.org Product; insurance details remain a public plan definition, not personal Coverage. */
+export declare function buildProductDirectoryResource(input: ProductDirectoryInput): DirectoryResource;
+/** Rejects native fields and converts a directory resource into deterministic array-valued claims. */
+export declare function normalizeDirectoryFlatClaimsResource(input: unknown): DirectoryFlatClaimsResource;
+/** Explicitly projects one neutral Place to native FHIR R5 Location for export or interop. */
+export declare function projectPlaceToFhirR5Location(place: DirectoryResource | DirectoryFlatClaimsResource): Readonly<{
+    resourceType: "Location";
+    id: string;
+    status: "active";
+    mode: "instance";
+    name: string | undefined;
+    description: string | undefined;
+    address: {
+        line?: (string | undefined)[] | undefined;
+        country: string | undefined;
+        state: string | undefined;
+        city: string | undefined;
+        postalCode: string;
+    };
+    position: {
+        altitude?: number | undefined;
+        latitude: number;
+        longitude: number;
+    };
+    managingOrganization: {
+        reference: string;
+    };
+    characteristic: {
+        coding: {
+            code: string;
+        }[];
+    }[];
+    hoursOfOperation: {
+        availableTime: {
+            daysOfWeek: string[];
+            availableStartTime: string;
+            availableEndTime: string;
+        }[];
+        notAvailableTime: {
+            description: string;
+            during: {
+                start: string;
+                end: string;
+            };
+        }[];
+    }[];
+    meta: {
+        claims: {
+            'Location.characteristic'?: readonly string[] | undefined;
+            'Location.identifier': string;
+            'Location.status': string;
+            'Location.name': string | undefined;
+            'Location.address-postalcode': string;
+            'Location.near': string;
+            'Location.organization': string;
+        };
+    };
+}>;
+/** Explicitly projects a neutral Service and its Places to native FHIR R5 HealthcareService. */
+export declare function projectServiceToFhirR5HealthcareService(service: DirectoryResource | DirectoryFlatClaimsResource, input: Readonly<{
+    places: readonly (DirectoryResource | DirectoryFlatClaimsResource)[];
+}>): Readonly<{
+    meta: {
+        claims: {
+            'HealthcareService.service-category'?: readonly string[] | undefined;
+            'HealthcareService.identifier': string;
+            'HealthcareService.organization': string;
+            'HealthcareService.name': string | undefined;
+            'HealthcareService.location': string[];
+            'HealthcareService.service-type': readonly 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;
+    }[];
+}>;
+/** Explicitly projects a public insurance Product definition to FHIR R5 InsurancePlan. */
+export declare function projectProductToFhirR5InsurancePlan(product: DirectoryResource | DirectoryFlatClaimsResource): Readonly<{
+    ownedBy: {
+        reference: string;
+    };
+    coverageArea: {
+        reference: string;
+    }[];
+    network: {
+        reference: string;
+    }[];
+    coverage: {
+        type: {
+            coding: {
+                code: string;
+            }[];
+        };
+        network: {
+            reference: string;
+        }[];
+        benefit: {
+            type: {
+                coding: {
+                    code: string;
+                }[];
+            };
+        }[];
+    }[];
+    meta: {
+        claims: {
+            'InsurancePlan.identifier': string;
+            'InsurancePlan.status': string;
+            'InsurancePlan.name': string;
+            'InsurancePlan.owned-by': string;
+            'InsurancePlan.type': string;
+        };
+    };
+    period?: {
+        start: string;
+        end: string;
+    } | undefined;
+    resourceType: "InsurancePlan";
+    id: string;
+    identifier: {
+        value: string;
+    }[];
+    status: string;
+    type: {
+        coding: {
+            code: string;
+        }[];
+    }[];
+    name: string;
+}>;
+/** Builds the Schema.org JSON-LD OfferCatalog presented by one organization. */
+export declare function buildOrganizationOfferCatalog(input: Readonly<{
+    id: string;
+    name: string;
+    organizationIdentifier: string;
+    sector: keyof typeof OrganizationOfferingKinds;
+    offerings: readonly (DirectoryResource | DirectoryFlatClaimsResource)[];
+}>): Readonly<{
+    '@context': "https://schema.org";
+    '@type': "OfferCatalog";
+    identifier: string;
+    name: string;
+    offeredBy: Readonly<{
+        '@type': "Organization";
+        identifier: string;
+    }>;
+    numberOfItems: number;
+    itemListElement: readonly Readonly<{
+        '@type': "Offer";
+        itemOffered: Readonly<{
+            '@type': "Service" | "Product";
+            identifier: string;
+            name: string;
+        }>;
+    }>[];
+}>;
+/** Advertises a transferable catalog snapshot as a DSP Dataset with an ODRL use Offer. */
+export declare function buildDataspaceCatalogAdvertisement(input: Readonly<{
+    catalogId: string;
+    participantId: string;
+    dataServiceId: string;
+    endpointUrl: string;
+    datasetId: string;
+    policyId: string;
+    distributionFormat: string;
+}>): Readonly<{
+    '@context': readonly "https://w3id.org/dspace/2025/1/context.jsonld"[];
+    '@id': string;
+    '@type': "Catalog";
+    participantId: string;
+    service: readonly Readonly<{
+        '@id': string;
+        '@type': "DataService";
+        endpointURL: string;
+    }>[];
+    dataset: readonly Readonly<{
+        '@id': string;
+        '@type': "Dataset";
+        hasPolicy: readonly Readonly<{
+            '@id': string;
+            '@type': "Offer";
+            permission: readonly Readonly<{
+                action: "use";
+            }>[];
+        }>[];
+        distribution: readonly Readonly<{
+            '@type': "Distribution";
+            format: string;
+            accessService: string;
+        }>[];
+    }>[];
+}>;
+/** Builds the DSP DataAddress exchanged only after agreement negotiation starts a transfer. */
+export declare function buildDataspaceDataAddress(input: Readonly<{
+    endpointType: string;
+    endpoint?: string;
+    endpointProperties?: readonly Readonly<{
+        name: string;
+        value: string;
+    }>[];
+}>): Readonly<{
+    endpointProperties?: readonly Readonly<{
+        '@type': "EndpointProperty";
+        name: string;
+        value: string;
+    }>[] | undefined;
+    endpoint?: string | undefined;
+    '@type': "DataAddress";
+    endpointType: string;
+}>;
+export type ClinicMarketplaceResult = Readonly<{
+    place: DirectoryResource | DirectoryFlatClaimsResource;
+    services: readonly (DirectoryResource | DirectoryFlatClaimsResource)[];
+    distanceKm?: number;
+}>;
+/** Joins and filters a public clinic directory by postal code, service and optional geographic radius. */
+export declare function searchClinicMarketplace(input: Readonly<{
+    places: readonly (DirectoryResource | DirectoryFlatClaimsResource)[];
+    services: readonly (DirectoryResource | DirectoryFlatClaimsResource)[];
+    postalCode?: string;
+    serviceTypes?: readonly string[];
+    near?: Readonly<{
+        latitude: number;
+        longitude: number;
+        radiusKm: number;
+    }>;
+}>): readonly ClinicMarketplaceResult[];

package/dist/place-service-directory.js

@@ -0,0 +1,550 @@
+// Copyright 2026 Connecting Solution & Applications Ltd under the Apache License, Version 2.0.
+/** Schema.org flat claims for a persistent, sector-neutral public Place. */
+export var ClaimsPlaceSchemaorg;
+(function (ClaimsPlaceSchemaorg) {
+    ClaimsPlaceSchemaorg["identifier"] = "org.schema.Place.identifier";
+    ClaimsPlaceSchemaorg["additionalType"] = "org.schema.Place.additionalType";
+    ClaimsPlaceSchemaorg["name"] = "org.schema.Place.name";
+    ClaimsPlaceSchemaorg["description"] = "org.schema.Place.description";
+    ClaimsPlaceSchemaorg["ownerIdentifier"] = "org.schema.Place.owner.identifier";
+    ClaimsPlaceSchemaorg["addressCountry"] = "org.schema.Place.address.addressCountry";
+    ClaimsPlaceSchemaorg["addressRegion"] = "org.schema.Place.address.addressRegion";
+    ClaimsPlaceSchemaorg["addressLocality"] = "org.schema.Place.address.addressLocality";
+    ClaimsPlaceSchemaorg["extendedAddress"] = "org.schema.Place.address.extendedAddress";
+    ClaimsPlaceSchemaorg["postalCode"] = "org.schema.Place.address.postalCode";
+    ClaimsPlaceSchemaorg["streetAddress"] = "org.schema.Place.address.streetAddress";
+    ClaimsPlaceSchemaorg["latitude"] = "org.schema.Place.geo.latitude";
+    ClaimsPlaceSchemaorg["longitude"] = "org.schema.Place.geo.longitude";
+    ClaimsPlaceSchemaorg["elevation"] = "org.schema.Place.geo.elevation";
+    ClaimsPlaceSchemaorg["photoContentUrl"] = "org.schema.Place.photo.contentUrl";
+    ClaimsPlaceSchemaorg["amenityFeature"] = "org.schema.Place.amenityFeature";
+    ClaimsPlaceSchemaorg["publicAccess"] = "org.schema.Place.publicAccess";
+    ClaimsPlaceSchemaorg["openingHoursSpecification"] = "org.schema.Place.openingHoursSpecification";
+    ClaimsPlaceSchemaorg["specialOpeningHoursSpecification"] = "org.schema.Place.specialOpeningHoursSpecification";
+    ClaimsPlaceSchemaorg["userSelected"] = "Place.user-selected";
+})(ClaimsPlaceSchemaorg || (ClaimsPlaceSchemaorg = {}));
+/** Schema.org Service claims needed to join a public service to one or more Places. */
+export var ClaimsDirectoryServiceSchemaorg;
+(function (ClaimsDirectoryServiceSchemaorg) {
+    ClaimsDirectoryServiceSchemaorg["identifier"] = "org.schema.Service.identifier";
+    ClaimsDirectoryServiceSchemaorg["name"] = "org.schema.Service.name";
+    ClaimsDirectoryServiceSchemaorg["description"] = "org.schema.Service.description";
+    ClaimsDirectoryServiceSchemaorg["providerIdentifier"] = "org.schema.Service.provider.identifier";
+    ClaimsDirectoryServiceSchemaorg["placeIdentifier"] = "org.schema.Service.availableChannel.serviceLocation.identifier";
+    ClaimsDirectoryServiceSchemaorg["serviceType"] = "org.schema.Service.serviceType";
+    ClaimsDirectoryServiceSchemaorg["category"] = "org.schema.Service.category";
+    ClaimsDirectoryServiceSchemaorg["areaServed"] = "org.schema.Service.areaServed";
+    ClaimsDirectoryServiceSchemaorg["userSelected"] = "Service.user-selected";
+})(ClaimsDirectoryServiceSchemaorg || (ClaimsDirectoryServiceSchemaorg = {}));
+/** Schema.org Product claims for an organization's public commercial offering. */
+export var ClaimsProductSchemaorg;
+(function (ClaimsProductSchemaorg) {
+    ClaimsProductSchemaorg["identifier"] = "org.schema.Product.identifier";
+    ClaimsProductSchemaorg["additionalType"] = "org.schema.Product.additionalType";
+    ClaimsProductSchemaorg["name"] = "org.schema.Product.name";
+    ClaimsProductSchemaorg["description"] = "org.schema.Product.description";
+    ClaimsProductSchemaorg["providerIdentifier"] = "org.schema.Product.provider.identifier";
+    ClaimsProductSchemaorg["category"] = "org.schema.Product.category";
+    ClaimsProductSchemaorg["areaServed"] = "org.schema.Product.areaServed";
+    ClaimsProductSchemaorg["url"] = "org.schema.Product.url";
+    ClaimsProductSchemaorg["imageContentUrl"] = "org.schema.Product.image.contentUrl";
+    ClaimsProductSchemaorg["availabilityStarts"] = "org.schema.Product.offers.availabilityStarts";
+    ClaimsProductSchemaorg["availabilityEnds"] = "org.schema.Product.offers.availabilityEnds";
+    ClaimsProductSchemaorg["price"] = "org.schema.Product.offers.price";
+    ClaimsProductSchemaorg["priceCurrency"] = "org.schema.Product.offers.priceCurrency";
+    ClaimsProductSchemaorg["insuranceStatus"] = "org.schema.Product.additionalProperty.insuranceStatus";
+    ClaimsProductSchemaorg["insuranceCoverageType"] = "org.schema.Product.additionalProperty.insuranceCoverageType";
+    ClaimsProductSchemaorg["insuranceNetwork"] = "org.schema.Product.additionalProperty.insuranceNetwork";
+    ClaimsProductSchemaorg["userSelected"] = "Product.user-selected";
+})(ClaimsProductSchemaorg || (ClaimsProductSchemaorg = {}));
+/** Product-local allowlist for the experimental Place, Service and Product directory profile. */
+export const DirectoryFlatClaimCatalog = Object.freeze({
+    Place: Object.freeze(Object.values(ClaimsPlaceSchemaorg)),
+    Service: Object.freeze(Object.values(ClaimsDirectoryServiceSchemaorg)),
+    Product: Object.freeze(Object.values(ClaimsProductSchemaorg)),
+});
+/** Sector-owned offering kind. It drives presentation only and grants no authority. */
+export const OrganizationOfferingKinds = Object.freeze({
+    'animal-care': 'Service',
+    'animal-insurance': 'Product',
+});
+/** Stable Eclipse Dataspace Protocol 2025-1 identifiers, including current editorial errata. */
+export const DataspaceProtocol2025 = Object.freeze({
+    release: '2025-1-err1',
+    context: 'https://w3id.org/dspace/2025/1/context.jsonld',
+    httpEndpointType: 'https://w3id.org/idsa/v4.1/HTTP',
+});
+const RESOURCE_ID_PATTERN = /^[A-Za-z0-9\-.]{1,64}$/;
+const TIME_PATTERN = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const DAY_NAMES = new Set(['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']);
+function required(value, code) {
+    const normalized = String(value ?? '').trim();
+    if (!normalized)
+        throw new TypeError(code);
+    return normalized;
+}
+function optional(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized || undefined;
+}
+function optionalHttpsUrl(value, code) {
+    const normalized = optional(value);
+    if (!normalized)
+        return undefined;
+    try {
+        const parsed = new URL(normalized);
+        if (parsed.protocol !== 'https:')
+            throw new Error();
+        return parsed.toString();
+    }
+    catch {
+        throw new TypeError(code);
+    }
+}
+function unique(values, code) {
+    const result = [...new Set((values ?? []).map(value => required(value, code)))];
+    return Object.freeze(result);
+}
+function assertCoordinate(value, minimum, maximum, code) {
+    if (!Number.isFinite(value) || value < minimum || value > maximum)
+        throw new TypeError(code);
+}
+function assertDate(value, code) {
+    if (!DATE_PATTERN.test(value) || Number.isNaN(Date.parse(`${value}T00:00:00Z`)))
+        throw new TypeError(code);
+    return value;
+}
+function timeMinutes(value, code) {
+    if (!TIME_PATTERN.test(value))
+        throw new TypeError(code);
+    const [hour, minute] = value.split(':').map(Number);
+    return hour * 60 + minute;
+}
+function encodeOpeningHours(value) {
+    const daysOfWeek = unique(value.daysOfWeek, 'place_opening_hours_invalid');
+    if (!daysOfWeek.length || daysOfWeek.some(day => !DAY_NAMES.has(day)))
+        throw new TypeError('place_opening_hours_invalid');
+    if (timeMinutes(value.opens, 'place_opening_hours_invalid') >= timeMinutes(value.closes, 'place_opening_hours_invalid'))
+        throw new TypeError('place_opening_hours_invalid');
+    const validFrom = value.validFrom ? assertDate(value.validFrom, 'place_opening_hours_invalid') : undefined;
+    const validThrough = value.validThrough ? assertDate(value.validThrough, 'place_opening_hours_invalid') : undefined;
+    if (Boolean(validFrom) !== Boolean(validThrough) || (validFrom && validThrough && validFrom > validThrough))
+        throw new TypeError('place_opening_hours_invalid');
+    return JSON.stringify({ daysOfWeek, opens: value.opens, closes: value.closes, ...(validFrom ? { validFrom, validThrough } : {}) });
+}
+function encodeSpecialOpeningHours(value) {
+    const validFrom = assertDate(value.validFrom, 'place_special_opening_hours_invalid');
+    const validThrough = assertDate(value.validThrough, 'place_special_opening_hours_invalid');
+    if (validFrom > validThrough)
+        throw new TypeError('place_special_opening_hours_invalid');
+    if (value.closed)
+        return JSON.stringify({ validFrom, validThrough, closed: true });
+    if (!value.opens || !value.closes || timeMinutes(value.opens, 'place_special_opening_hours_invalid') >= timeMinutes(value.closes, 'place_special_opening_hours_invalid'))
+        throw new TypeError('place_special_opening_hours_invalid');
+    return JSON.stringify({ validFrom, validThrough, opens: value.opens, closes: value.closes });
+}
+/** Builds the claims-only public Place authored by an organization. */
+export function buildPlaceDirectoryResource(input) {
+    const id = required(input.id, 'place_id_required');
+    if (!RESOURCE_ID_PATTERN.test(id))
+        throw new TypeError('place_id_invalid');
+    assertCoordinate(input.position.latitude, -90, 90, 'place_latitude_invalid');
+    assertCoordinate(input.position.longitude, -180, 180, 'place_longitude_invalid');
+    if (input.position.elevation !== undefined && !Number.isFinite(input.position.elevation))
+        throw new TypeError('place_elevation_invalid');
+    let photoUrl;
+    if (input.photoUrl) {
+        try {
+            const parsed = new URL(input.photoUrl);
+            if (parsed.protocol !== 'https:')
+                throw new Error();
+            photoUrl = parsed.toString();
+        }
+        catch {
+            throw new TypeError('place_photo_url_invalid');
+        }
+    }
+    const accessibilityFeatures = unique(input.accessibilityFeatures, 'place_amenity_feature_invalid');
+    const openingHours = Object.freeze((input.openingHours ?? []).map(encodeOpeningHours));
+    const specialOpeningHours = Object.freeze((input.specialOpeningHours ?? []).map(encodeSpecialOpeningHours));
+    const claims = {
+        [ClaimsPlaceSchemaorg.identifier]: id,
+        [ClaimsPlaceSchemaorg.ownerIdentifier]: required(input.organizationIdentifier, 'place_organization_required'),
+        [ClaimsPlaceSchemaorg.name]: required(input.name, 'place_name_required'),
+        [ClaimsPlaceSchemaorg.addressCountry]: required(input.address.addressCountry, 'place_country_required').toUpperCase(),
+        [ClaimsPlaceSchemaorg.postalCode]: required(input.address.postalCode, 'place_postal_code_required'),
+        [ClaimsPlaceSchemaorg.latitude]: input.position.latitude,
+        [ClaimsPlaceSchemaorg.longitude]: input.position.longitude,
+        [ClaimsPlaceSchemaorg.publicAccess]: input.publicAccess ?? true,
+        [ClaimsPlaceSchemaorg.userSelected]: input.userSelected ?? false,
+    };
+    const textValues = [
+        [ClaimsPlaceSchemaorg.additionalType, input.additionalType], [ClaimsPlaceSchemaorg.description, input.description],
+        [ClaimsPlaceSchemaorg.addressRegion, input.address.addressRegion], [ClaimsPlaceSchemaorg.addressLocality, input.address.addressLocality],
+        [ClaimsPlaceSchemaorg.extendedAddress, input.address.extendedAddress], [ClaimsPlaceSchemaorg.streetAddress, input.address.streetAddress],
+    ];
+    for (const [name, raw] of textValues) {
+        const value = optional(raw);
+        if (value)
+            claims[name] = value;
+    }
+    if (input.position.elevation !== undefined)
+        claims[ClaimsPlaceSchemaorg.elevation] = input.position.elevation;
+    if (photoUrl)
+        claims[ClaimsPlaceSchemaorg.photoContentUrl] = photoUrl;
+    if (accessibilityFeatures.length)
+        claims[ClaimsPlaceSchemaorg.amenityFeature] = accessibilityFeatures;
+    if (openingHours.length)
+        claims[ClaimsPlaceSchemaorg.openingHoursSpecification] = openingHours;
+    if (specialOpeningHours.length)
+        claims[ClaimsPlaceSchemaorg.specialOpeningHoursSpecification] = specialOpeningHours;
+    return Object.freeze({ resourceType: 'Place', id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
+}
+/** Builds a claims-only Schema.org Service joined to its provider and public Places. */
+export function buildServiceDirectoryResource(input) {
+    const id = required(input.id, 'service_id_required');
+    if (!RESOURCE_ID_PATTERN.test(id))
+        throw new TypeError('service_id_invalid');
+    const placeIdentifiers = unique(input.placeIdentifiers, 'service_place_required');
+    const serviceTypes = unique(input.serviceTypes, 'service_type_required');
+    if (!placeIdentifiers.length)
+        throw new TypeError('service_place_required');
+    if (!serviceTypes.length)
+        throw new TypeError('service_type_required');
+    const categories = unique(input.categories, 'service_category_invalid');
+    const areaServed = unique(input.areaServed, 'service_area_invalid');
+    const claims = {
+        [ClaimsDirectoryServiceSchemaorg.identifier]: id,
+        [ClaimsDirectoryServiceSchemaorg.providerIdentifier]: required(input.organizationIdentifier, 'service_organization_required'),
+        [ClaimsDirectoryServiceSchemaorg.placeIdentifier]: placeIdentifiers,
+        [ClaimsDirectoryServiceSchemaorg.name]: required(input.name, 'service_name_required'),
+        [ClaimsDirectoryServiceSchemaorg.serviceType]: serviceTypes,
+        [ClaimsDirectoryServiceSchemaorg.userSelected]: input.userSelected ?? false,
+    };
+    const description = optional(input.description);
+    if (description)
+        claims[ClaimsDirectoryServiceSchemaorg.description] = description;
+    if (categories.length)
+        claims[ClaimsDirectoryServiceSchemaorg.category] = categories;
+    if (areaServed.length)
+        claims[ClaimsDirectoryServiceSchemaorg.areaServed] = areaServed;
+    return Object.freeze({ resourceType: 'Service', id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
+}
+/** Builds a claims-only Schema.org Product; insurance details remain a public plan definition, not personal Coverage. */
+export function buildProductDirectoryResource(input) {
+    const id = required(input.id, 'product_id_required');
+    if (!RESOURCE_ID_PATTERN.test(id))
+        throw new TypeError('product_id_invalid');
+    const productType = required(input.productType, 'product_type_required');
+    const categories = unique(input.categories, 'product_category_invalid');
+    const areaServed = unique(input.areaServed, 'product_area_invalid');
+    const url = optionalHttpsUrl(input.url, 'product_url_invalid');
+    const imageUrl = optionalHttpsUrl(input.imageUrl, 'product_image_url_invalid');
+    const availableFrom = input.availableFrom ? assertDate(input.availableFrom, 'product_period_invalid') : undefined;
+    const availableThrough = input.availableThrough ? assertDate(input.availableThrough, 'product_period_invalid') : undefined;
+    if (Boolean(availableFrom) !== Boolean(availableThrough) || (availableFrom && availableThrough && availableFrom > availableThrough))
+        throw new TypeError('product_period_invalid');
+    if (input.price !== undefined && (!Number.isFinite(input.price) || input.price < 0))
+        throw new TypeError('product_price_invalid');
+    const priceCurrency = optional(input.priceCurrency)?.toUpperCase();
+    if ((input.price === undefined) !== (priceCurrency === undefined) || (priceCurrency && !/^[A-Z]{3}$/.test(priceCurrency)))
+        throw new TypeError('product_price_invalid');
+    if (productType === 'insurance-plan' && !input.insurance)
+        throw new TypeError('insurance_product_profile_required');
+    const coverageTypes = unique(input.insurance?.coverageTypes, 'insurance_coverage_type_invalid');
+    if (input.insurance && !coverageTypes.length)
+        throw new TypeError('insurance_coverage_type_invalid');
+    const networks = unique(input.insurance?.networks, 'insurance_network_invalid');
+    const claims = {
+        [ClaimsProductSchemaorg.identifier]: id,
+        [ClaimsProductSchemaorg.providerIdentifier]: required(input.organizationIdentifier, 'product_organization_required'),
+        [ClaimsProductSchemaorg.name]: required(input.name, 'product_name_required'),
+        [ClaimsProductSchemaorg.additionalType]: productType,
+        [ClaimsProductSchemaorg.userSelected]: input.userSelected ?? false,
+    };
+    const description = optional(input.description);
+    if (description)
+        claims[ClaimsProductSchemaorg.description] = description;
+    if (categories.length)
+        claims[ClaimsProductSchemaorg.category] = categories;
+    if (areaServed.length)
+        claims[ClaimsProductSchemaorg.areaServed] = areaServed;
+    if (url)
+        claims[ClaimsProductSchemaorg.url] = url;
+    if (imageUrl)
+        claims[ClaimsProductSchemaorg.imageContentUrl] = imageUrl;
+    if (availableFrom)
+        claims[ClaimsProductSchemaorg.availabilityStarts] = availableFrom;
+    if (availableThrough)
+        claims[ClaimsProductSchemaorg.availabilityEnds] = availableThrough;
+    if (input.price !== undefined)
+        claims[ClaimsProductSchemaorg.price] = input.price;
+    if (priceCurrency)
+        claims[ClaimsProductSchemaorg.priceCurrency] = priceCurrency;
+    if (input.insurance)
+        claims[ClaimsProductSchemaorg.insuranceStatus] = input.insurance.status;
+    if (coverageTypes.length)
+        claims[ClaimsProductSchemaorg.insuranceCoverageType] = coverageTypes;
+    if (networks.length)
+        claims[ClaimsProductSchemaorg.insuranceNetwork] = networks;
+    return Object.freeze({ resourceType: 'Product', id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
+}
+/** Rejects native fields and converts a directory resource into deterministic array-valued claims. */
+export function normalizeDirectoryFlatClaimsResource(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new TypeError('directory_flat_resource_invalid');
+    const value = input;
+    if ((value.resourceType !== 'Place' && value.resourceType !== 'Service' && value.resourceType !== 'Product') || Object.keys(value).some(key => !['resourceType', 'id', 'meta'].includes(key)))
+        throw new TypeError('directory_flat_resource_invalid');
+    const resourceType = value.resourceType;
+    const id = required(value.id, 'directory_flat_resource_invalid');
+    if (!RESOURCE_ID_PATTERN.test(id))
+        throw new TypeError('directory_flat_resource_invalid');
+    const rawClaims = value.meta?.claims;
+    if (!rawClaims || typeof rawClaims !== 'object' || Array.isArray(rawClaims))
+        throw new TypeError('directory_flat_resource_invalid');
+    const allowed = new Set(DirectoryFlatClaimCatalog[resourceType]);
+    const claims = {};
+    for (const [name, raw] of Object.entries(rawClaims)) {
+        if (!allowed.has(name))
+            throw new TypeError('directory_flat_claim_invalid');
+        const values = (Array.isArray(raw) ? raw : [raw]).map(item => String(item).trim());
+        if (!values.length || values.some(item => !item))
+            throw new TypeError('directory_flat_claim_invalid');
+        claims[name] = Object.freeze([...new Set(values)]);
+    }
+    return Object.freeze({ resourceType, id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
+}
+function values(resource, name) {
+    const raw = resource.meta.claims[name];
+    return (Array.isArray(raw) ? raw : raw === undefined ? [] : [raw]).map(String);
+}
+function first(resource, name) {
+    return values(resource, name)[0];
+}
+function parseJson(value, code) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new TypeError(code);
+    }
+}
+/** Explicitly projects one neutral Place to native FHIR R5 Location for export or interop. */
+export function projectPlaceToFhirR5Location(place) {
+    if (place.resourceType !== 'Place')
+        throw new TypeError('place_resource_required');
+    const latitude = Number(first(place, ClaimsPlaceSchemaorg.latitude));
+    const longitude = Number(first(place, ClaimsPlaceSchemaorg.longitude));
+    const postalCode = required(first(place, ClaimsPlaceSchemaorg.postalCode), 'place_postal_code_required');
+    const owner = required(first(place, ClaimsPlaceSchemaorg.ownerIdentifier), 'place_organization_required');
+    const opening = values(place, ClaimsPlaceSchemaorg.openingHoursSpecification).map(value => parseJson(value, 'place_opening_hours_invalid'));
+    const special = values(place, ClaimsPlaceSchemaorg.specialOpeningHoursSpecification).map(value => parseJson(value, 'place_special_opening_hours_invalid'));
+    const address = {
+        country: first(place, ClaimsPlaceSchemaorg.addressCountry), state: first(place, ClaimsPlaceSchemaorg.addressRegion),
+        city: first(place, ClaimsPlaceSchemaorg.addressLocality), postalCode,
+        ...(first(place, ClaimsPlaceSchemaorg.streetAddress) ? { line: [first(place, ClaimsPlaceSchemaorg.streetAddress)] } : {}),
+    };
+    const availableTime = opening.map(period => ({
+        daysOfWeek: period.daysOfWeek.map(day => day.slice(0, 3).toLowerCase()),
+        availableStartTime: period.opens, availableEndTime: period.closes,
+    }));
+    const notAvailableTime = special.filter(period => period.closed).map(period => ({
+        description: 'Special closure', during: { start: period.validFrom, end: period.validThrough },
+    }));
+    return Object.freeze({
+        resourceType: 'Location', id: place.id, status: 'active', mode: 'instance',
+        name: first(place, ClaimsPlaceSchemaorg.name), description: first(place, ClaimsPlaceSchemaorg.description),
+        address, position: { latitude, longitude, ...(first(place, ClaimsPlaceSchemaorg.elevation) ? { altitude: Number(first(place, ClaimsPlaceSchemaorg.elevation)) } : {}) },
+        managingOrganization: { reference: owner },
+        characteristic: values(place, ClaimsPlaceSchemaorg.amenityFeature).map(code => ({ coding: [{ code }] })),
+        hoursOfOperation: [{ availableTime, notAvailableTime }],
+        meta: { claims: {
+                'Location.identifier': place.id, 'Location.status': 'active', 'Location.name': first(place, ClaimsPlaceSchemaorg.name),
+                'Location.address-postalcode': postalCode, 'Location.near': `${latitude}|${longitude}`, 'Location.organization': owner,
+                ...(values(place, ClaimsPlaceSchemaorg.amenityFeature).length ? { 'Location.characteristic': values(place, ClaimsPlaceSchemaorg.amenityFeature) } : {}),
+            } },
+    });
+}
+/** Explicitly projects a neutral Service and its Places to native FHIR R5 HealthcareService. */
+export function projectServiceToFhirR5HealthcareService(service, input) {
+    if (service.resourceType !== 'Service')
+        throw new TypeError('service_resource_required');
+    const placeIdentifiers = values(service, ClaimsDirectoryServiceSchemaorg.placeIdentifier);
+    const places = placeIdentifiers.map(identifier => {
+        const place = input.places.find(candidate => candidate.resourceType === 'Place' && candidate.id === identifier);
+        if (!place)
+            throw new TypeError('service_place_not_found');
+        return place;
+    });
+    const serviceTypes = values(service, ClaimsDirectoryServiceSchemaorg.serviceType);
+    const categories = values(service, ClaimsDirectoryServiceSchemaorg.category);
+    const organization = required(first(service, ClaimsDirectoryServiceSchemaorg.providerIdentifier), 'service_organization_required');
+    const photoUrl = places.map(place => first(place, ClaimsPlaceSchemaorg.photoContentUrl)).find(Boolean);
+    const concept = (code) => ({ coding: [{ code }] });
+    return Object.freeze({
+        resourceType: 'HealthcareService', id: service.id, active: true, providedBy: { reference: organization },
+        name: first(service, ClaimsDirectoryServiceSchemaorg.name), comment: first(service, ClaimsDirectoryServiceSchemaorg.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': service.id, 'HealthcareService.organization': organization,
+                'HealthcareService.name': first(service, ClaimsDirectoryServiceSchemaorg.name),
+                'HealthcareService.location': places.map(place => `Location/${place.id}`),
+                'HealthcareService.service-type': serviceTypes,
+                ...(categories.length ? { 'HealthcareService.service-category': categories } : {}),
+            } },
+    });
+}
+/** Explicitly projects a public insurance Product definition to FHIR R5 InsurancePlan. */
+export function projectProductToFhirR5InsurancePlan(product) {
+    if (product.resourceType !== 'Product')
+        throw new TypeError('product_resource_required');
+    if (first(product, ClaimsProductSchemaorg.additionalType) !== 'insurance-plan')
+        throw new TypeError('insurance_product_required');
+    const organization = required(first(product, ClaimsProductSchemaorg.providerIdentifier), 'product_organization_required');
+    const status = required(first(product, ClaimsProductSchemaorg.insuranceStatus), 'insurance_product_profile_required');
+    const coverageTypes = values(product, ClaimsProductSchemaorg.insuranceCoverageType);
+    if (!coverageTypes.length)
+        throw new TypeError('insurance_coverage_type_invalid');
+    const networks = values(product, ClaimsProductSchemaorg.insuranceNetwork);
+    const areaServed = values(product, ClaimsProductSchemaorg.areaServed);
+    const name = required(first(product, ClaimsProductSchemaorg.name), 'product_name_required');
+    const start = first(product, ClaimsProductSchemaorg.availabilityStarts);
+    const end = first(product, ClaimsProductSchemaorg.availabilityEnds);
+    const concept = (code) => ({ coding: [{ code }] });
+    return Object.freeze({
+        resourceType: 'InsurancePlan', id: product.id,
+        identifier: [{ value: product.id }], status, type: [concept('insurance-plan')], name,
+        ...(start && end ? { period: { start, end } } : {}),
+        ownedBy: { reference: organization },
+        coverageArea: areaServed.map(reference => ({ reference })),
+        network: networks.map(reference => ({ reference })),
+        coverage: coverageTypes.map(type => ({ type: concept(type), network: networks.map(reference => ({ reference })), benefit: [{ type: concept(type) }] })),
+        meta: { claims: {
+                'InsurancePlan.identifier': product.id,
+                'InsurancePlan.status': status,
+                'InsurancePlan.name': name,
+                'InsurancePlan.owned-by': organization,
+                'InsurancePlan.type': 'insurance-plan',
+            } },
+    });
+}
+/** Builds the Schema.org JSON-LD OfferCatalog presented by one organization. */
+export function buildOrganizationOfferCatalog(input) {
+    const expectedKind = OrganizationOfferingKinds[input.sector];
+    const organizationIdentifier = required(input.organizationIdentifier, 'organization_identifier_required');
+    const itemListElement = input.offerings.map(offering => {
+        if (offering.resourceType !== expectedKind)
+            throw new TypeError('organization_offering_kind_invalid');
+        const isService = offering.resourceType === 'Service';
+        const nameClaim = isService ? ClaimsDirectoryServiceSchemaorg.name : ClaimsProductSchemaorg.name;
+        const providerClaim = isService ? ClaimsDirectoryServiceSchemaorg.providerIdentifier : ClaimsProductSchemaorg.providerIdentifier;
+        if (first(offering, providerClaim) !== organizationIdentifier)
+            throw new TypeError('organization_offering_owner_invalid');
+        return Object.freeze({
+            '@type': 'Offer',
+            itemOffered: Object.freeze({
+                '@type': offering.resourceType,
+                identifier: offering.id,
+                name: required(first(offering, nameClaim), 'organization_offering_name_required'),
+            }),
+        });
+    });
+    return Object.freeze({
+        '@context': 'https://schema.org', '@type': 'OfferCatalog',
+        identifier: required(input.id, 'organization_catalog_id_required'),
+        name: required(input.name, 'organization_catalog_name_required'),
+        offeredBy: Object.freeze({ '@type': 'Organization', identifier: organizationIdentifier }),
+        numberOfItems: itemListElement.length,
+        itemListElement: Object.freeze(itemListElement),
+    });
+}
+/** Advertises a transferable catalog snapshot as a DSP Dataset with an ODRL use Offer. */
+export function buildDataspaceCatalogAdvertisement(input) {
+    const endpointURL = optionalHttpsUrl(input.endpointUrl, 'dataspace_endpoint_url_invalid');
+    if (!endpointURL)
+        throw new TypeError('dataspace_endpoint_url_invalid');
+    const dataServiceId = required(input.dataServiceId, 'dataspace_data_service_id_required');
+    const datasetId = required(input.datasetId, 'dataspace_dataset_id_required');
+    const service = Object.freeze({ '@id': dataServiceId, '@type': 'DataService', endpointURL });
+    const dataset = Object.freeze({
+        '@id': datasetId,
+        '@type': 'Dataset',
+        hasPolicy: Object.freeze([Object.freeze({
+                '@id': required(input.policyId, 'dataspace_policy_id_required'),
+                '@type': 'Offer',
+                permission: Object.freeze([Object.freeze({ action: 'use' })]),
+            })]),
+        distribution: Object.freeze([Object.freeze({
+                '@type': 'Distribution',
+                format: required(input.distributionFormat, 'dataspace_distribution_format_required'),
+                accessService: dataServiceId,
+            })]),
+    });
+    return Object.freeze({
+        '@context': Object.freeze([DataspaceProtocol2025.context]),
+        '@id': required(input.catalogId, 'dataspace_catalog_id_required'),
+        '@type': 'Catalog',
+        participantId: required(input.participantId, 'dataspace_participant_id_required'),
+        service: Object.freeze([service]),
+        dataset: Object.freeze([dataset]),
+    });
+}
+/** Builds the DSP DataAddress exchanged only after agreement negotiation starts a transfer. */
+export function buildDataspaceDataAddress(input) {
+    const endpointType = required(input.endpointType, 'dataspace_data_address_invalid');
+    if (!endpointType.startsWith('https://'))
+        throw new TypeError('dataspace_data_address_invalid');
+    const endpoint = optionalHttpsUrl(input.endpoint, 'dataspace_data_address_invalid');
+    const endpointProperties = (input.endpointProperties ?? []).map(property => Object.freeze({
+        '@type': 'EndpointProperty',
+        name: required(property.name, 'dataspace_data_address_invalid'),
+        value: required(property.value, 'dataspace_data_address_invalid'),
+    }));
+    return Object.freeze({
+        '@type': 'DataAddress', endpointType,
+        ...(endpoint ? { endpoint } : {}),
+        ...(endpointProperties.length ? { endpointProperties: Object.freeze(endpointProperties) } : {}),
+    });
+}
+function normalizedPostal(value) { return value.replace(/[^A-Za-z0-9]/g, '').toUpperCase(); }
+function distanceKm(left, right) {
+    const radians = (value) => value * Math.PI / 180;
+    const lat = radians(right.latitude - left.latitude);
+    const lon = radians(right.longitude - left.longitude);
+    const a = Math.sin(lat / 2) ** 2 + Math.cos(radians(left.latitude)) * Math.cos(radians(right.latitude)) * Math.sin(lon / 2) ** 2;
+    return 6371 * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+/** Joins and filters a public clinic directory by postal code, service and optional geographic radius. */
+export function searchClinicMarketplace(input) {
+    const postalCode = input.postalCode ? normalizedPostal(required(input.postalCode, 'marketplace_postal_code_invalid')) : undefined;
+    const requestedTypes = new Set(unique(input.serviceTypes, 'marketplace_service_type_invalid'));
+    if (input.near) {
+        assertCoordinate(input.near.latitude, -90, 90, 'marketplace_latitude_invalid');
+        assertCoordinate(input.near.longitude, -180, 180, 'marketplace_longitude_invalid');
+        if (!Number.isFinite(input.near.radiusKm) || input.near.radiusKm <= 0)
+            throw new TypeError('marketplace_radius_invalid');
+    }
+    const results = [];
+    for (const place of input.places) {
+        if (place.resourceType !== 'Place')
+            throw new TypeError('place_resource_required');
+        if (postalCode && normalizedPostal(String(first(place, ClaimsPlaceSchemaorg.postalCode) || '')) !== postalCode)
+            continue;
+        const services = input.services.filter(service => service.resourceType === 'Service'
+            && values(service, ClaimsDirectoryServiceSchemaorg.placeIdentifier).includes(place.id)
+            && (!requestedTypes.size || values(service, ClaimsDirectoryServiceSchemaorg.serviceType).some(type => requestedTypes.has(type))));
+        if (!services.length)
+            continue;
+        const distance = input.near ? distanceKm(input.near, {
+            latitude: Number(first(place, ClaimsPlaceSchemaorg.latitude)), longitude: Number(first(place, ClaimsPlaceSchemaorg.longitude)),
+        }) : undefined;
+        if (input.near && (distance === undefined || distance > input.near.radiusKm))
+            continue;
+        results.push(Object.freeze({ place, services: Object.freeze(services), ...(distance === undefined ? {} : { distanceKm: distance }) }));
+    }
+    return Object.freeze(results.sort((left, right) => (left.distanceKm ?? 0) - (right.distanceKm ?? 0) || left.place.id.localeCompare(right.place.id)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-data-utils-ts",
-  "version": "0.5.20",
+  "version": "0.5.22",
   "description": "Browser-safe governed VetChain data contracts",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -68,6 +68,10 @@
       "types": "./dist/payment.d.ts",
       "default": "./dist/payment.js"
     },
+    "./place-service-directory": {
+      "types": "./dist/place-service-directory.d.ts",
+      "default": "./dist/place-service-directory.js"
+    },
     "./research-study": {
       "types": "./dist/research-study.d.ts",
       "default": "./dist/research-study.js"