@carrot-foundation/schemas 0.1.6

package/dist/mass-id/mass-id.schema.js

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+import { NftIpfsSchema } from '../shared/nft.schema.js';
+import { MassIDDataSchema } from './mass-id.data.schema.js';
+import { WasteTypeSchema, WasteSubtypeSchema, WeightKgSchema, } from '../shared/definitions.schema.js';
+const AttributeWasteTypeSchema = z
+    .strictObject({
+    trait_type: z.literal('Waste Type'),
+    value: WasteTypeSchema,
+})
+    .meta({
+    title: 'Waste Type Attribute',
+    description: 'Waste type attribute',
+});
+const AttributeWasteSubtypeSchema = z
+    .strictObject({
+    trait_type: z.literal('Waste Subtype'),
+    value: WasteSubtypeSchema,
+})
+    .meta({
+    title: 'Waste Subtype Attribute',
+    description: 'Waste subtype attribute',
+});
+const AttributeWeightSchema = z
+    .strictObject({
+    trait_type: z.literal('Weight (kg)'),
+    value: WeightKgSchema,
+    display_type: z.literal('number'),
+})
+    .meta({
+    title: 'Weight Attribute',
+    description: 'Weight attribute with numeric display',
+});
+const AttributeOriginCountrySchema = z
+    .strictObject({
+    trait_type: z.literal('Origin Country'),
+    value: z.string().max(100).meta({
+        title: 'Origin Country Value',
+        description: 'Country where the waste was generated',
+    }),
+})
+    .meta({
+    title: 'Origin Country Attribute',
+    description: 'Origin country attribute',
+});
+const AttributeOriginMunicipalitySchema = z
+    .strictObject({
+    trait_type: z.literal('Origin Municipality'),
+    value: z.string().max(100).meta({
+        title: 'Origin Municipality Value',
+        description: 'Municipality where the waste was generated',
+    }),
+})
+    .meta({
+    title: 'Origin Municipality Attribute',
+    description: 'Origin municipality attribute',
+});
+const AttributeOriginDivisionSchema = z
+    .strictObject({
+    trait_type: z.literal('Origin Administrative Division'),
+    value: z.string().max(100).meta({
+        title: 'Origin Division Value',
+        description: 'Administrative division (state/province) where the waste was generated',
+    }),
+})
+    .meta({
+    title: 'Origin Administrative Division Attribute',
+    description: 'Origin administrative division attribute',
+});
+const AttributeRecyclerSchema = z
+    .strictObject({
+    trait_type: z.literal('Recycler'),
+    value: z.string().max(100).meta({
+        title: 'Recycler Value',
+        description: 'Organization that processed the waste',
+    }),
+})
+    .meta({
+    title: 'Recycler Attribute',
+    description: 'Recycler attribute',
+});
+const AttributeIntegratorSchema = z
+    .strictObject({
+    trait_type: z.literal('Integrator'),
+    value: z.string().max(100).meta({
+        title: 'Integrator Value',
+        description: 'Organization that integrated the waste into the Carrot network',
+    }),
+})
+    .meta({
+    title: 'Integrator Attribute',
+    description: 'Integrator attribute',
+});
+const AttributePickUpDateSchema = z
+    .strictObject({
+    trait_type: z.literal('Pick-up Date'),
+    value: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Must be a valid date in YYYY-MM-DD format')
+        .meta({
+        title: 'Pick-up Date Value',
+        description: 'Date when the waste was picked up from the source',
+    }),
+    display_type: z.literal('date'),
+})
+    .meta({
+    title: 'Pick-up Date Attribute',
+    description: 'Pick-up date attribute',
+});
+const AttributeRecyclingDateSchema = z
+    .strictObject({
+    trait_type: z.literal('Recycling Date'),
+    value: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Must be a valid date in YYYY-MM-DD format')
+        .meta({
+        title: 'Recycling Date Value',
+        description: 'Date when the waste was recycled/processed',
+    }),
+    display_type: z.literal('date'),
+})
+    .meta({
+    title: 'Recycling Date Attribute',
+    description: 'Recycling date attribute',
+});
+const MassIDAttributesSchema = z
+    .tuple([
+    AttributeWasteTypeSchema,
+    AttributeWasteSubtypeSchema,
+    AttributeWeightSchema,
+    AttributeOriginCountrySchema,
+    AttributeOriginMunicipalitySchema,
+    AttributeOriginDivisionSchema,
+    AttributeRecyclerSchema,
+    AttributeIntegratorSchema,
+    AttributePickUpDateSchema,
+    AttributeRecyclingDateSchema,
+])
+    .meta({
+    title: 'MassID Attributes',
+    description: 'Fixed set of MassID NFT attributes in required order',
+});
+export const MassIDIpfsSchema = NftIpfsSchema.safeExtend({
+    schema: NftIpfsSchema.shape.schema.safeExtend({
+        type: z.literal('MassID').meta({
+            title: 'MassID Schema Type',
+            description: 'MassID NFT schema type',
+        }),
+    }),
+    attributes: MassIDAttributesSchema.meta({
+        title: 'MassID NFT Attributes',
+        description: 'Fixed set of MassID NFT attributes enforcing order and type for each trait',
+    }).check(z.minLength(10), z.maxLength(10)),
+    data: MassIDDataSchema.meta({
+        title: 'MassID Data',
+        description: 'MassID-specific data containing waste tracking and chain of custody information',
+    }),
+}).meta({
+    title: 'MassID NFT IPFS Record',
+    description: 'Complete MassID NFT IPFS record including fixed attributes and detailed waste tracking data',
+    $id: 'https://raw.githubusercontent.com/carrot-foundation/schemas/refs/heads/main/schemas/ipfs/mass-id/mass-id.schema.json',
+    version: '1.0.0',
+});

package/dist/shared/base.schema.js

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+import { Keccak256HashSchema, SemanticVersionSchema, Sha256HashSchema, IsoTimestampSchema, ExternalIdSchema, ExternalUrlSchema, UuidSchema, RecordSchemaTypeSchema, IpfsUriSchema, RecordRelationshipTypeSchema, } from './definitions.schema.js';
+const SchemaInfoSchema = z
+    .strictObject({
+    hash: Keccak256HashSchema.meta({
+        title: 'Schema Hash',
+        description: 'Keccak256 hash of the JSON Schema this record was validated against',
+    }),
+    type: RecordSchemaTypeSchema.meta({
+        title: 'Schema Type',
+        description: 'Type/category of this schema',
+    }),
+    version: SemanticVersionSchema.meta({
+        title: 'Schema Version',
+        description: 'Version of the schema, using semantic versioning',
+    }),
+})
+    .meta({
+    title: 'Schema Information',
+});
+const RecordCreatorSchema = z
+    .strictObject({
+    name: z.string().meta({
+        title: 'Creator Name',
+        description: 'Company or individual name that created this record',
+        examples: ['Carrot Foundation', 'Alice', 'Bob'],
+    }),
+    id: UuidSchema.meta({
+        title: 'Creator ID',
+        description: 'Unique identifier for the creator',
+    }),
+})
+    .meta({
+    title: 'Creator',
+    description: 'Entity that created this record',
+});
+const RecordRelationshipSchema = z
+    .strictObject({
+    target_uri: IpfsUriSchema.meta({
+        title: 'Target IPFS URI',
+        description: 'Target IPFS URI of the referenced record',
+    }),
+    type: RecordRelationshipTypeSchema.meta({
+        title: 'Relationship Type',
+        description: 'Type of relationship to the referenced record',
+    }),
+    description: z
+        .string()
+        .optional()
+        .meta({
+        title: 'Relationship Description',
+        description: 'Human-readable description of the relationship',
+        examples: [
+            'This record supersedes the previous version',
+            'Related carbon credit batch',
+            'Source document for this verification',
+            'Child record derived from this parent',
+            'Updated version of original record',
+        ],
+    }),
+})
+    .meta({
+    title: 'Relationship',
+    description: 'Relationship to another IPFS record',
+});
+export const RecordEnvironmentSchema = z
+    .strictObject({
+    blockchain_network: z.enum(['mainnet', 'testnet']).meta({
+        title: 'Blockchain Network',
+        description: 'Blockchain Network Environment',
+    }),
+    deployment: z.enum(['production', 'development', 'testing']).meta({
+        title: 'Deployment Environment',
+        description: 'System environment where this record was generated',
+    }),
+    data_set_name: z.enum(['TEST', 'PROD']).meta({
+        title: 'Data Set Name',
+        description: 'Name of the data set for this record',
+    }),
+})
+    .meta({
+    title: 'Environment',
+    description: 'Environment information',
+});
+export const BaseIpfsSchema = z
+    .strictObject({
+    $schema: z.url('Must be a valid URI').meta({
+        title: 'JSON Schema URI',
+        description: 'URI of the JSON Schema used to validate this record',
+        example: 'https://raw.githubusercontent.com/carrot-foundation/schemas/refs/heads/main/schemas/ipfs/shared/base/base.schema.json',
+    }),
+    schema: SchemaInfoSchema,
+    created_at: IsoTimestampSchema.meta({
+        title: 'Created At',
+        description: 'ISO 8601 creation timestamp for this record',
+    }),
+    external_id: ExternalIdSchema.meta({
+        title: 'External ID',
+        description: 'Off-chain reference ID (UUID from Carrot backend)',
+    }),
+    external_url: ExternalUrlSchema.meta({
+        title: 'External URL',
+        description: 'External URL of the content',
+    }),
+    original_content_hash: Sha256HashSchema.meta({
+        title: 'Original Content Hash',
+        description: 'SHA-256 hash of the original JSON content including private data before schema validation',
+    }),
+    content_hash: Sha256HashSchema.meta({
+        title: 'Content Hash',
+        description: 'SHA-256 hash of RFC 8785 canonicalized JSON after schema validation',
+    }),
+    creator: RecordCreatorSchema.optional(),
+    relationships: z.array(RecordRelationshipSchema).optional().meta({
+        title: 'Relationships',
+        description: 'References to other IPFS records this record relates to',
+    }),
+    environment: RecordEnvironmentSchema.optional(),
+    data: z.record(z.string(), z.unknown()).optional().meta({
+        title: 'Custom Data',
+        description: "Custom data block that includes the record's data",
+    }),
+})
+    .meta({
+    title: 'Base IPFS Record',
+    description: 'Base fields for all Carrot IPFS records, providing common structure for any JSON content stored in IPFS',
+});

package/dist/shared/definitions.schema.js

@@ -0,0 +1,283 @@
+import { z } from 'zod';
+export const UuidSchema = z.uuidv4('Must be a valid UUID v4 string').meta({
+    title: 'UUID',
+    description: 'A universally unique identifier version 4',
+    examples: [
+        'ad44dd3f-f176-4b98-bf78-5ee6e77d0530',
+        '6f520d88-864d-432d-bf9f-5c3166c4818f',
+        'f77afa89-1c58-40fd-9bf5-8a86703a8af4',
+    ],
+});
+export const EthereumAddressSchema = z
+    .string()
+    .regex(/^0x[a-fA-F0-9]{40}$/, 'Must be a valid Ethereum address in lowercase hexadecimal format')
+    .meta({
+    title: 'Ethereum Address',
+    description: 'A valid Ethereum address in hexadecimal format',
+    examples: [
+        '0x1234567890abcdef1234567890abcdef12345678',
+        '0xabcdef1234567890abcdef1234567890abcdef12',
+    ],
+});
+export const IsoTimestampSchema = z.iso
+    .datetime({
+    message: 'Must be a valid ISO 8601 timestamp with timezone',
+})
+    .meta({
+    title: 'ISO Timestamp',
+    description: 'ISO 8601 formatted timestamp with timezone information',
+    examples: ['2024-12-05T11:02:47.000Z', '2025-02-22T10:35:12.000Z'],
+});
+export const IsoDateSchema = z.iso
+    .date('Must be a valid ISO 8601 date (YYYY-MM-DD)')
+    .meta({
+    title: 'ISO Date',
+    description: 'ISO 8601 formatted date in YYYY-MM-DD format',
+    examples: ['2024-12-05', '2025-02-22', '2024-02-10'],
+});
+export const IsoCountryCodeSchema = z
+    .string()
+    .regex(/^[A-Z]{2}$/, 'Must be a valid ISO 3166-1 alpha-2 country code')
+    .meta({
+    title: 'ISO Country Code',
+    description: 'Two-letter country code following ISO 3166-1 alpha-2 standard',
+    examples: ['BR', 'US', 'DE'],
+});
+export const IsoAdministrativeDivisionCodeSchema = z
+    .string()
+    .regex(/^[A-Z]{2}-[A-Z0-9]{1,3}$/, 'Must be a valid ISO 3166-2 administrative division code')
+    .meta({
+    title: 'ISO Administrative Division Code',
+    description: 'Administrative division code following ISO 3166-2 standard',
+    examples: ['BR-AP', 'BR-ES', 'US-CA'],
+});
+export const LatitudeSchema = z
+    .number()
+    .min(-90)
+    .max(90)
+    .meta({
+    title: 'Latitude',
+    description: 'Geographic latitude coordinate in decimal degrees',
+    examples: [-0.02, -20.38, 40.7128],
+});
+export const LongitudeSchema = z
+    .number()
+    .min(-180)
+    .max(180)
+    .meta({
+    title: 'Longitude',
+    description: 'Geographic longitude coordinate in decimal degrees',
+    examples: [-51.06, -40.34, -74.006],
+});
+export const WeightKgSchema = z
+    .number()
+    .min(0)
+    .meta({
+    title: 'Weight (kg)',
+    description: 'Weight measurement in kilograms',
+    examples: [3000, 1500, 500],
+});
+export const NonEmptyStringSchema = z
+    .string()
+    .min(1, 'Cannot be empty')
+    .meta({
+    title: 'Non-Empty String',
+    description: 'A string that contains at least one character',
+    examples: ['Example text', 'Sample value', 'Test string'],
+});
+export const SlugSchema = NonEmptyStringSchema.regex(/^[a-z0-9-]+$/, 'Must contain only lowercase letters, numbers, and hyphens')
+    .max(100)
+    .meta({
+    title: 'Slug',
+    description: 'URL-friendly identifier with lowercase letters, numbers, and hyphens',
+    examples: ['mass-id-123', 'recycled-plastic', 'organic-waste'],
+});
+export const WasteTypeSchema = NonEmptyStringSchema.meta({
+    title: 'Waste Type',
+    description: 'Category or type of waste material',
+    examples: ['Organic', 'Plastic', 'Metal'],
+});
+export const WasteSubtypeSchema = NonEmptyStringSchema.max(100).meta({
+    title: 'Waste Subtype',
+    description: 'Specific subcategory of waste within a waste type',
+    examples: ['Food, Food Waste and Beverages', 'PET Bottles', 'Aluminum Cans'],
+});
+export const ParticipantRoleSchema = NonEmptyStringSchema.max(100).meta({
+    title: 'Participant Role',
+    description: 'Role that a participant plays in the waste management supply chain',
+    examples: ['Waste Generator', 'Hauler', 'Recycler'],
+});
+export const ParticipantNameSchema = NonEmptyStringSchema.max(100).meta({
+    title: 'Participant Name',
+    description: 'Name of a participant in the waste management system',
+    examples: ['Enlatados Produção', 'Eco Reciclagem', 'Green Tech Corp'],
+});
+export const FacilityTypeSchema = z
+    .enum([
+    'Waste Generation',
+    'Collection Point',
+    'Transfer Station',
+    'Sorting Facility',
+    'Composting Facility',
+    'Recycling Facility',
+    'Processing Facility',
+    'Disposal Facility',
+    'Administrative Office',
+])
+    .meta({
+    title: 'Facility Type',
+    description: 'Type of facility in the waste management infrastructure',
+    examples: ['Waste Generation', 'Recycling Facility', 'Collection Point'],
+});
+export const BlockchainChainIdSchema = z
+    .number()
+    .int()
+    .min(1)
+    .meta({
+    title: 'Chain ID',
+    description: 'Blockchain network identifier',
+    examples: [1, 137, 11155111],
+});
+export const PercentageSchema = z
+    .number()
+    .min(0)
+    .max(100)
+    .meta({
+    title: 'Percentage',
+    description: 'Percentage value between 0 and 100',
+    examples: [50, 75.5, 100],
+});
+export const NonNegativeIntegerSchema = z
+    .number()
+    .int()
+    .min(0)
+    .meta({
+    title: 'Non-Negative Integer',
+    description: 'Integer value that is zero or positive',
+    examples: [0, 123, 4126],
+});
+export const PositiveIntegerSchema = z
+    .number()
+    .int()
+    .min(1)
+    .meta({
+    title: 'Positive Integer',
+    description: 'Integer value that is greater than zero',
+    examples: [1, 123, 456],
+});
+export const NonNegativeFloatSchema = z
+    .number()
+    .min(0)
+    .meta({
+    title: 'Non-Negative Float',
+    description: 'Floating-point number that is zero or positive',
+    examples: [0.0, 45.2, 72.5],
+});
+export const HoursSchema = z
+    .number()
+    .min(0)
+    .multipleOf(0.1)
+    .meta({
+    title: 'Hours',
+    description: 'Time duration in hours with 0.1 hour precision',
+    examples: [72.5, 24.0, 168.5],
+});
+export const IpfsUriSchema = NonEmptyStringSchema.regex(/^ipfs:\/\/[a-zA-Z0-9]+(\/.*)?$/, 'Must be a valid IPFS URI with CID').meta({
+    title: 'IPFS URI',
+    description: 'InterPlanetary File System URI pointing to distributed content',
+    examples: [
+        'ipfs://QmTy8w65yBXgyfG2ZBg5TrfB2hPjrDQH3RCQFJGkARStJb/mass-id-organic.png',
+        'ipfs://QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o',
+    ],
+});
+export const SemanticVersionSchema = NonEmptyStringSchema.regex(/^v?\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/, 'Must be a valid semantic version string').meta({
+    title: 'Semantic Version',
+    description: 'Version string following semantic versioning specification',
+    examples: ['0.1.0', '1.0.0', '2.1.3'],
+});
+export const TokenIdSchema = NonEmptyStringSchema.regex(/^\d+$/, 'Must be a numeric string (supports uint256)').meta({
+    title: 'Token ID',
+    description: 'Numeric identifier for blockchain tokens as string',
+    examples: ['123', '456789', '1000000'],
+});
+export const HexColorSchema = NonEmptyStringSchema.regex(/^#[0-9A-F]{6}$/, 'Must be a hex color code with # prefix and uppercase').meta({
+    title: 'Hex Color',
+    description: 'Hexadecimal color code with hash prefix',
+    examples: ['#2D5A27', '#FF5733', '#1E90FF'],
+});
+export const Sha256HashSchema = z
+    .hash('sha256', {
+    error: 'Must be a SHA256 hash as 32-byte hex string',
+})
+    .meta({
+    format: undefined,
+    title: 'SHA256 Hash',
+    description: 'SHA-256 cryptographic hash as hexadecimal string',
+    examples: [
+        '87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489',
+        '6e83b8e6373847bbdc056549bedda38dc88854ce41ba4fca11e0fc6ce3e07ef6',
+    ],
+});
+export const Keccak256HashSchema = Sha256HashSchema.meta({
+    title: 'Keccak256 Hash',
+    description: 'Keccak256 cryptographic hash as hexadecimal string',
+    examples: [
+        'ac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f',
+        'b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2',
+    ],
+});
+export const ExternalIdSchema = UuidSchema.meta({
+    title: 'External ID',
+    description: 'UUID identifier for external system references',
+    examples: [
+        'ad44dd3f-f176-4b98-bf78-5ee6e77d0530',
+        'b2c4e6f8-a1b3-4c5d-9e8f-123456789abc',
+    ],
+});
+export const ExternalUrlSchema = z.url('Must be a valid URL').meta({
+    title: 'External URL',
+    description: 'Valid URL pointing to external resources',
+    examples: [
+        'https://explore.carrot.eco/document/ad44dd3f-f176-4b98-bf78-5ee6e77d0530',
+        'https://carrot.eco/whitepaper.pdf',
+    ],
+});
+export const RecordSchemaTypeSchema = z
+    .enum([
+    'MassID',
+    'MassID Audit',
+    'RecycledID',
+    'GasID',
+    'PurchaseID',
+    'Methodology',
+    'Credit',
+    'Collection',
+])
+    .meta({
+    title: 'Schema Type',
+    description: 'Type of schema in the Carrot ecosystem',
+    examples: ['MassID', 'RecycledID', 'GasID'],
+});
+export const TokenSymbolSchema = NonEmptyStringSchema.max(10)
+    .regex(/^[A-Z0-9-]+$/, 'Must contain only uppercase letters, numbers, and hyphens')
+    .meta({
+    title: 'Token Symbol',
+    description: 'Symbol representing a token or cryptocurrency',
+    examples: ['MASS', 'REC', 'GAS'],
+});
+export const RecordRelationshipTypeSchema = z
+    .enum([
+    'collection',
+    'credit',
+    'gas-id',
+    'mass-id',
+    'mass-id-audit',
+    'methodology',
+    'purchase-id',
+    'recycled-id',
+])
+    .meta({
+    title: 'Relationship Type',
+    description: 'Type of relationship between different entities in the system',
+    examples: ['mass-id', 'audit', 'collection'],
+});

package/dist/shared/entities/location.schema.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { UuidSchema, NonEmptyStringSchema, LatitudeSchema, LongitudeSchema, IsoCountryCodeSchema, IsoAdministrativeDivisionCodeSchema, FacilityTypeSchema, } from '../definitions.schema.js';
+const PrecisionLevelSchema = z
+    .enum(['exact', 'neighborhood', 'city', 'region', 'country'])
+    .meta({
+    title: 'Precision Level',
+    description: 'Level of coordinate precision',
+    examples: ['city', 'exact', 'neighborhood'],
+});
+export const CoordinatesSchema = z
+    .strictObject({
+    latitude: LatitudeSchema.meta({
+        title: 'Latitude',
+        description: 'GPS latitude coordinate',
+    }),
+    longitude: LongitudeSchema.meta({
+        title: 'Longitude',
+        description: 'GPS longitude coordinate',
+    }),
+    precision_level: PrecisionLevelSchema,
+})
+    .meta({
+    title: 'Coordinates',
+    description: 'GPS coordinates of the location',
+});
+export const LocationSchema = z
+    .strictObject({
+    id: UuidSchema.meta({
+        title: 'Location ID',
+        description: 'Unique identifier for the location',
+    }),
+    municipality: NonEmptyStringSchema.max(50).meta({
+        title: 'Municipality',
+        description: 'Municipality or city name',
+        examples: ['New York', 'São Paulo', 'London', 'Tokyo'],
+    }),
+    administrative_division: NonEmptyStringSchema.max(50).meta({
+        title: 'Administrative Division',
+        description: 'State, province, or administrative region',
+        examples: ['California', 'Ontario', 'Bavaria', 'Queensland'],
+    }),
+    administrative_division_code: IsoAdministrativeDivisionCodeSchema.meta({
+        title: 'Administrative Division Code',
+        description: 'ISO 3166-2 administrative division code',
+    }),
+    country: NonEmptyStringSchema.max(50).meta({
+        title: 'Country',
+        description: 'Full country name in English',
+        examples: ['United States', 'Canada', 'Germany', 'Australia'],
+    }),
+    country_code: IsoCountryCodeSchema.meta({
+        title: 'Country Code',
+        description: 'ISO 3166-1 alpha-2 country code',
+    }),
+    responsible_participant_id: UuidSchema.meta({
+        title: 'Responsible Participant ID',
+        description: 'ID of the participant responsible for this location',
+    }),
+    coordinates: CoordinatesSchema,
+    facility_type: FacilityTypeSchema.meta({
+        title: 'Facility Type',
+        description: 'Type of facility at this location',
+    }),
+})
+    .meta({
+    title: 'Location',
+    description: 'Geographic location with address and coordinate information',
+});

package/dist/shared/entities/participant.schema.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { UuidSchema, ParticipantNameSchema, ParticipantRoleSchema, } from '../definitions.schema.js';
+import { uniqueArrayItems } from '../helpers.schema.js';
+export const ParticipantSchema = z
+    .strictObject({
+    id: UuidSchema.meta({
+        title: 'Participant ID',
+        description: 'Unique identifier for the participant',
+    }),
+    name: ParticipantNameSchema.meta({
+        title: 'Participant Name',
+        description: 'Name of the participant',
+    }),
+    roles: uniqueArrayItems(ParticipantRoleSchema, 'Participant roles must be unique')
+        .min(1)
+        .meta({
+        title: 'Participant Roles',
+        description: 'Roles of the participant in the waste management supply chain',
+    }),
+})
+    .meta({
+    title: 'Participant',
+    description: 'A participant in the waste management supply chain',
+});

package/dist/shared/helpers.schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export function uniqueArrayItems(schema, errorMessage = 'Array items must be unique') {
+    return z
+        .array(schema)
+        .refine((items) => new Set(items).size === items.length, {
+        message: errorMessage,
+    });
+}
+export function uniqueBy(schema, selector, errorMessage = 'Items must be unique') {
+    return z.array(schema).refine((items) => {
+        const values = items.map(selector);
+        return new Set(values).size === values.length;
+    }, {
+        message: errorMessage,
+    });
+}