vet-data-utils-ts 0.5.21 → 0.5.23

package/README.md

@@ -2,12 +2,24 @@
 
 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` resources. Photos, accessibility, coordinates, address
-and opening-hours specifications remain neutral indexed claims. Native FHIR R5
-`Location` and `HealthcareService` are produced only by explicit projection
-helpers; the shared `gdc-*` claim catalog is unchanged while this profile is
+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/place-service-directory.d.ts

@@ -33,10 +33,31 @@ export declare enum ClaimsDirectoryServiceSchemaorg {
     areaServed = "org.schema.Service.areaServed",
     userSelected = "Service.user-selected"
 }
-/** Product-local allowlist for the experimental Place and Service directory profile. */
+/** 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[];
@@ -105,11 +126,52 @@ export type ServiceDirectoryInput = Readonly<{
     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";
+}>;
+/** Complete VetChain organization-sector presentation allowlist. */
+export declare const OrganizationOfferingKindsBySector: Readonly<{
+    readonly 'animal-care': readonly ["Service"];
+    readonly 'animal-insurance': readonly ["Product"];
+    readonly 'animal-tech': readonly ["Service", "Product"];
+    readonly 'animal-research': readonly ["Service"];
+}>;
+/** 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;
-/** Rejects native fields and converts a Place or Service into deterministic array-valued claims. */
+/** 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<{
@@ -204,6 +266,140 @@ export declare function projectServiceToFhirR5HealthcareService(service: Directo
         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 OrganizationOfferingKindsBySector;
+    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': "Place" | "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)[];

package/dist/place-service-directory.js

@@ -36,10 +36,50 @@ export var ClaimsDirectoryServiceSchemaorg;
     ClaimsDirectoryServiceSchemaorg["areaServed"] = "org.schema.Service.areaServed";
     ClaimsDirectoryServiceSchemaorg["userSelected"] = "Service.user-selected";
 })(ClaimsDirectoryServiceSchemaorg || (ClaimsDirectoryServiceSchemaorg = {}));
-/** Product-local allowlist for the experimental Place and Service directory profile. */
+/** 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',
+});
+/** Complete VetChain organization-sector presentation allowlist. */
+export const OrganizationOfferingKindsBySector = Object.freeze({
+    'animal-care': Object.freeze(['Service']),
+    'animal-insurance': Object.freeze(['Product']),
+    'animal-tech': Object.freeze(['Service', 'Product']),
+    'animal-research': Object.freeze(['Service']),
+});
+/** 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$/;
@@ -55,6 +95,20 @@ 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);
@@ -184,12 +238,71 @@ export function buildServiceDirectoryResource(input) {
         claims[ClaimsDirectoryServiceSchemaorg.areaServed] = areaServed;
     return Object.freeze({ resourceType: 'Service', id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
 }
-/** Rejects native fields and converts a Place or Service into deterministic array-valued 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') || Object.keys(value).some(key => !['resourceType', 'id', 'meta'].includes(key)))
+    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');
@@ -292,6 +405,118 @@ export function projectServiceToFhirR5HealthcareService(service, input) {
             } },
     });
 }
+/** 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 allowedKinds = OrganizationOfferingKindsBySector[input.sector];
+    const organizationIdentifier = required(input.organizationIdentifier, 'organization_identifier_required');
+    const itemListElement = input.offerings.map(offering => {
+        if (!allowedKinds.includes(offering.resourceType))
+            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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-data-utils-ts",
-  "version": "0.5.21",
+  "version": "0.5.23",
   "description": "Browser-safe governed VetChain data contracts",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",