@carrot-foundation/schemas 0.1.20 → 0.1.21

package/dist/index.js

@@ -1 +1,1100 @@
-export * from './mass-id';
+import { z } from 'zod';
+
+// src/mass-id/mass-id.data.schema.ts
+var 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"
+  ]
+});
+var 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"
+  ]
+});
+var 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"]
+});
+var 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"]
+});
+var 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"]
+});
+var 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"]
+});
+var LatitudeSchema = z.number().min(-90).max(90).meta({
+  title: "Latitude",
+  description: "Geographic latitude coordinate in decimal degrees",
+  examples: [-0.02, -20.38, 40.7128]
+});
+var LongitudeSchema = z.number().min(-180).max(180).meta({
+  title: "Longitude",
+  description: "Geographic longitude coordinate in decimal degrees",
+  examples: [-51.06, -40.34, -74.006]
+});
+var WeightKgSchema = z.number().min(0).meta({
+  title: "Weight (kg)",
+  description: "Weight measurement in kilograms",
+  examples: [3e3, 1500, 500]
+});
+var 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"]
+});
+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"]
+});
+var WasteTypeSchema = NonEmptyStringSchema.meta({
+  title: "Waste Type",
+  description: "Category or type of waste material",
+  examples: ["Organic", "Plastic", "Metal"]
+});
+var 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"]
+});
+var 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"]
+});
+var ParticipantNameSchema = NonEmptyStringSchema.max(100).meta({
+  title: "Participant Name",
+  description: "Name of a participant in the waste management system",
+  examples: ["Enlatados Produ\xE7\xE3o", "Eco Reciclagem", "Green Tech Corp"]
+});
+var 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"]
+});
+var BlockchainChainIdSchema = z.number().int().min(1).meta({
+  title: "Chain ID",
+  description: "Blockchain network identifier",
+  examples: [1, 137, 11155111]
+});
+z.number().min(0).max(100).meta({
+  title: "Percentage",
+  description: "Percentage value between 0 and 100",
+  examples: [50, 75.5, 100]
+});
+z.number().int().min(0).meta({
+  title: "Non-Negative Integer",
+  description: "Integer value that is zero or positive",
+  examples: [0, 123, 4126]
+});
+z.number().int().min(1).meta({
+  title: "Positive Integer",
+  description: "Integer value that is greater than zero",
+  examples: [1, 123, 456]
+});
+var NonNegativeFloatSchema = z.number().min(0).meta({
+  title: "Non-Negative Float",
+  description: "Floating-point number that is zero or positive",
+  examples: [0, 45.2, 72.5]
+});
+var 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, 168.5]
+});
+var 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"
+  ]
+});
+var 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"]
+});
+var 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"]
+});
+var 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"]
+});
+var Sha256HashSchema = z.hash("sha256", {
+  error: "Must be a SHA256 hash as 32-byte hex string"
+}).meta({
+  format: void 0,
+  title: "SHA256 Hash",
+  description: "SHA-256 cryptographic hash as hexadecimal string",
+  examples: [
+    "87f633634cc4b02f628685651f0a29b7bfa22a0bd841f725c6772dd00a58d489",
+    "6e83b8e6373847bbdc056549bedda38dc88854ce41ba4fca11e0fc6ce3e07ef6"
+  ]
+});
+var Keccak256HashSchema = Sha256HashSchema.meta({
+  title: "Keccak256 Hash",
+  description: "Keccak256 cryptographic hash as hexadecimal string",
+  examples: [
+    "ac08c3cf2e175e55961d6affdb38bc24591b84ceef7f3707c69ae3d52c148b2f",
+    "b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2"
+  ]
+});
+var ExternalIdSchema = UuidSchema.meta({
+  title: "External ID",
+  description: "UUID identifier for external system references",
+  examples: [
+    "ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
+    "b2c4e6f8-a1b3-4c5d-9e8f-123456789abc"
+  ]
+});
+var 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"
+  ]
+});
+var 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"]
+});
+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"]
+});
+var 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"]
+});
+var PrecisionLevelSchema = z.enum(["exact", "neighborhood", "city", "region", "country"]).meta({
+  title: "Precision Level",
+  description: "Level of coordinate precision",
+  examples: ["city", "exact", "neighborhood"]
+});
+var 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"
+});
+var 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\xE3o 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.optional().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.optional().meta({
+    title: "Facility Type",
+    description: "Type of facility at this location"
+  })
+}).meta({
+  title: "Location",
+  description: "Geographic location with address and coordinate information"
+});
+function uniqueArrayItems(schema, errorMessage = "Array items must be unique") {
+  return z.array(schema).refine((items) => new Set(items).size === items.length, {
+    message: errorMessage
+  });
+}
+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
+    }
+  );
+}
+
+// src/shared/entities/participant.schema.ts
+var 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"
+});
+
+// src/mass-id/mass-id.data.schema.ts
+var MassIDLocalClassificationSchema = z.strictObject({
+  code: NonEmptyStringSchema.max(20).meta({
+    title: "Classification Code",
+    description: "Local waste classification code",
+    examples: ["20 01 01", "D001", "EWC-150101", "IBAMA-A001"]
+  }),
+  description: NonEmptyStringSchema.max(200).meta({
+    title: "Classification Description",
+    description: "Local waste classification description",
+    examples: [
+      "Paper and cardboard packaging",
+      "Ignitable waste",
+      "Paper and cardboard packaging waste",
+      "Municipal solid waste - organic fraction"
+    ]
+  }),
+  system: NonEmptyStringSchema.max(50).meta({
+    title: "Classification System",
+    description: 'Classification system name (e.g., "Ibama Waste Code", "European Waste Catalogue", "US EPA Codes")',
+    examples: [
+      "European Waste Catalogue",
+      "US EPA Codes",
+      "Ibama Waste Code",
+      "Brazilian ABNT Classification"
+    ]
+  })
+}).meta({
+  title: "Local Classification",
+  description: "Local or regional waste classification codes and descriptions"
+});
+var MassIDMeasurementUnitSchema = z.enum(["kg", "ton"]).meta({
+  title: "Measurement Unit",
+  description: "Unit of measurement for the waste quantity",
+  examples: ["kg", "ton"]
+});
+var ContaminationLevelSchema = z.enum(["None", "Low", "Medium", "High"]).meta({
+  title: "Contamination Level",
+  description: "Level of contamination in the waste batch",
+  examples: ["Low", "Medium", "None"]
+});
+var MassIDWasteClassificationSchema = z.strictObject({
+  primary_type: WasteTypeSchema.meta({
+    title: "Primary Waste Type",
+    description: "Primary waste material category"
+  }),
+  subtype: WasteSubtypeSchema.meta({
+    title: "Waste Subtype",
+    description: "Specific subcategory of waste material"
+  }),
+  local_classification: MassIDLocalClassificationSchema.optional(),
+  measurement_unit: MassIDMeasurementUnitSchema,
+  net_weight: NonNegativeFloatSchema.meta({
+    title: "Net Weight",
+    description: "Net weight of the waste batch in the specified measurement unit"
+  }),
+  contamination_level: ContaminationLevelSchema.optional()
+}).meta({
+  title: "Waste Classification",
+  description: "Standardized waste material classification and regulatory information"
+});
+var EventAttributeFormatSchema = z.enum(["KILOGRAM", "DATE", "CURRENCY", "PERCENTAGE", "COORDINATE"]).meta({
+  title: "Event Attribute Format",
+  description: "Data format hint for proper display",
+  examples: ["KILOGRAM", "DATE", "PERCENTAGE"]
+});
+var EventAttributeSchema = z.strictObject({
+  name: NonEmptyStringSchema.max(100).meta({
+    title: "Attribute Name",
+    description: "Event attribute name",
+    examples: [
+      "temperature",
+      "humidity",
+      "contamination_percentage",
+      "quality_grade",
+      "batch_number",
+      "operator_id",
+      "equipment_used",
+      "processing_cost"
+    ]
+  }),
+  value: z.union([z.string(), z.number(), z.boolean()]).meta({
+    title: "Attribute Value",
+    description: "Event attribute value",
+    examples: [
+      25.5,
+      "Grade A",
+      true,
+      "BATCH-2024-001",
+      12.75,
+      "Shredder-X200",
+      false,
+      "OP-456"
+    ]
+  }),
+  format: EventAttributeFormatSchema.optional()
+}).meta({
+  title: "Event Attribute",
+  description: "Additional attribute specific to an event"
+});
+var EventDocumentSchema = z.strictObject({
+  type: NonEmptyStringSchema.max(50).meta({
+    title: "Document Type",
+    description: "Type of supporting documentation",
+    examples: [
+      "Waste Transfer Note",
+      "Certificate of Disposal",
+      "Certificate of Final Destination",
+      "Quality Assessment Report",
+      "Transport Manifest",
+      "Processing Receipt",
+      "Environmental Permit",
+      "Invoice"
+    ]
+  }),
+  document_number: NonEmptyStringSchema.max(50).optional().meta({
+    title: "Document Number",
+    description: "Official document number if applicable",
+    examples: [
+      "WTN-2024-001234",
+      "CD-ENV-456789",
+      "INV-2024-QTR1-789",
+      "PERMIT-EPA-2024-001",
+      "MANIFEST-DOT-567890"
+    ]
+  }),
+  reference: NonEmptyStringSchema.meta({
+    title: "Document Reference",
+    description: "Reference to document (IPFS hash, file name, or external URL)",
+    examples: [
+      "QmYjtig7VJQ6XsnUjqqJvj7QaMcCAwtrgNdahSiFofrE7o",
+      "waste_transfer_note_2024_001.pdf",
+      "https://docs.example.com/certificates/disposal_cert_456.pdf",
+      "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi",
+      "processing_receipt_20240315.jpg"
+    ]
+  }),
+  issue_date: IsoDateSchema.optional().meta({
+    title: "Issue Date",
+    description: "Date the document was issued"
+  }),
+  issuer: NonEmptyStringSchema.max(100).optional().meta({
+    title: "Document Issuer",
+    description: "Entity that issued the document",
+    examples: [
+      "Environmental Protection Agency",
+      "Waste Management Solutions Ltd",
+      "Green Recycling Corp",
+      "City Waste Authority",
+      "EcoProcess Industries",
+      "Regional Environmental Office"
+    ]
+  })
+}).meta({
+  title: "Event Document",
+  description: "Supporting event document"
+});
+var MassIDChainOfCustodyEventSchema = z.strictObject({
+  event_id: UuidSchema.meta({
+    title: "Event ID",
+    description: "Unique event identifier"
+  }),
+  event_name: NonEmptyStringSchema.max(50).meta({
+    title: "Event Name",
+    description: "Name of custody or processing event",
+    examples: ["Sorting", "Processing", "Recycling", "Weighing"]
+  }),
+  description: NonEmptyStringSchema.max(200).optional().meta({
+    title: "Event Description",
+    description: "Detailed description of what happened during this event",
+    examples: [
+      "Waste collected from residential area using collection truck",
+      "Material sorted into recyclable and non-recyclable fractions",
+      "Plastic waste processed through shredding and washing",
+      "Waste transferred to authorized recycling facility",
+      "Final disposal at licensed landfill site",
+      "Quality inspection and contamination assessment completed"
+    ]
+  }),
+  timestamp: IsoTimestampSchema.meta({
+    title: "Event Timestamp",
+    description: "ISO 8601 timestamp when the event occurred"
+  }),
+  participant_id: UuidSchema.meta({
+    title: "Participant ID",
+    description: "Reference to participant in the participants array"
+  }),
+  location_id: UuidSchema.meta({
+    title: "Location ID",
+    description: "Reference to location in the locations array"
+  }),
+  weight: NonNegativeFloatSchema.optional().meta({
+    title: "Event Weight",
+    description: "Mass weight after this event"
+  }),
+  attributes: z.array(EventAttributeSchema).optional().meta({
+    title: "Event Attributes",
+    description: "Additional attributes specific to this event"
+  }),
+  documentation: z.array(EventDocumentSchema).optional().meta({
+    title: "Event Documentation",
+    description: "Associated documentation for this event"
+  }),
+  notes: NonEmptyStringSchema.max(500).optional().meta({
+    title: "Event Notes",
+    description: "Additional notes or comments about this event"
+  })
+}).meta({
+  title: "Chain of Custody Event",
+  description: "Chain of custody event"
+});
+var MassIDChainOfCustodySchema = z.strictObject({
+  events: z.array(MassIDChainOfCustodyEventSchema).min(1).meta({
+    title: "Custody Events",
+    description: "Chronological sequence of custody transfer and processing events"
+  }),
+  total_distance_km: NonNegativeFloatSchema.meta({
+    title: "Total Distance (km)",
+    description: "Total distance traveled across all transport events"
+  }),
+  total_duration_hours: HoursSchema.meta({
+    title: "Total Duration (hours)",
+    description: "Total time from first to last event in hours"
+  })
+}).meta({
+  title: "Chain of Custody",
+  description: "Complete chain of custody tracking from waste generation to final processing"
+});
+var MassIDTransportRouteSchema = z.strictObject({
+  from_location_id: UuidSchema.meta({
+    title: "From Location ID",
+    description: "Reference to the origin location in the locations array"
+  }),
+  to_location_id: UuidSchema.meta({
+    title: "To Location ID",
+    description: "Reference to the destination location in the locations array"
+  }),
+  distance_km: NonNegativeFloatSchema.meta({
+    title: "Distance (km)",
+    description: "Distance for this route segment in kilometers"
+  }),
+  transport_method: NonEmptyStringSchema.max(50).meta({
+    title: "Transport Method",
+    description: "Method of transportation for this segment",
+    examples: [
+      "Truck",
+      "Rail",
+      "Barge",
+      "Container Ship",
+      "Conveyor Belt",
+      "Pipeline",
+      "Walking",
+      "Forklift"
+    ]
+  }),
+  duration_hours: HoursSchema.meta({
+    title: "Duration (hours)",
+    description: "Time taken for this route segment in hours"
+  })
+}).meta({
+  title: "Transport Route",
+  description: "Transport route segment information"
+});
+var MassIDGeographicDataSchema = z.strictObject({
+  origin_location_id: UuidSchema.meta({
+    title: "Origin Location ID",
+    description: "Reference to origin location in the locations array"
+  }),
+  processing_location_ids: z.array(UuidSchema).optional().meta({
+    title: "Processing Location IDs",
+    description: "Locations where the waste was processed or handled"
+  }),
+  final_destination_id: UuidSchema.meta({
+    title: "Final Destination ID",
+    description: "Reference to final destination in the locations array"
+  }),
+  transport_routes: z.array(MassIDTransportRouteSchema).meta({
+    title: "Transport Routes",
+    description: "Detailed transport route information"
+  })
+}).meta({
+  title: "Geographic Data",
+  description: "Geographic information about waste origin and processing locations"
+});
+var MassIDDataSchema = z.strictObject({
+  waste_classification: MassIDWasteClassificationSchema,
+  locations: uniqueBy(
+    LocationSchema,
+    (loc) => loc.id,
+    "Location IDs must be unique"
+  ).min(1).meta({
+    title: "Locations",
+    description: "All locations referenced in this MassID, indexed by ID"
+  }),
+  participants: uniqueBy(
+    ParticipantSchema,
+    (p) => p.id,
+    "Participant IDs must be unique"
+  ).min(1).meta({
+    title: "Participants",
+    description: "All participants referenced in this MassID, indexed by ID"
+  }),
+  chain_of_custody: MassIDChainOfCustodySchema,
+  geographic_data: MassIDGeographicDataSchema
+}).refine((data) => {
+  const participantIdSet = new Set(
+    data.participants.map((participant) => participant.id)
+  );
+  const eventParticipantIds = data.chain_of_custody.events.map(
+    (event) => event.participant_id
+  );
+  const allEventParticipantsExist = eventParticipantIds.every(
+    (participantId) => participantIdSet.has(participantId)
+  );
+  return allEventParticipantsExist;
+}, "All participant IDs in chain of custody events must exist in participants array").refine((data) => {
+  const locationIdSet = new Set(
+    data.locations.map((location) => location.id)
+  );
+  const eventLocationIds = data.chain_of_custody.events.map(
+    (event) => event.location_id
+  );
+  const allEventLocationsExist = eventLocationIds.every(
+    (locationId) => locationIdSet.has(locationId)
+  );
+  return allEventLocationsExist;
+}, "All location IDs in chain of custody events must exist in locations array").meta({
+  title: "MassID Data",
+  description: "MassID data containing waste tracking and chain of custody information"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+
+// src/shared/nft.schema.ts
+var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
+  "MassID",
+  "RecycledID",
+  "GasID",
+  "PurchaseID"
+]).meta({
+  title: "NFT Schema Type",
+  description: "Type of schema for NFT records"
+});
+var BlockchainReferenceSchema = z.strictObject({
+  smart_contract_address: EthereumAddressSchema.meta({
+    title: "Smart Contract Address"
+  }),
+  chain_id: BlockchainChainIdSchema.meta({
+    title: "Chain ID",
+    description: "Blockchain chain ID"
+  }),
+  network_name: z.string().min(5).max(100).meta({
+    title: "Network Name",
+    description: "Name of the blockchain network"
+  }),
+  token_id: TokenIdSchema.meta({
+    title: "Token ID",
+    description: "NFT token ID"
+  })
+}).meta({
+  title: "Blockchain Information",
+  description: "Blockchain-specific information for the NFT"
+});
+var ExternalLinkSchema = z.strictObject({
+  label: z.string().min(1).max(50).meta({
+    title: "Link Label",
+    description: "Display name for the external link"
+  }),
+  url: z.url("Must be a valid URI").meta({
+    title: "Link URL",
+    description: "Direct URI to the linked resource"
+  }),
+  description: z.string().min(10).max(100).optional().meta({
+    title: "Link Description",
+    description: "Optional context about what the link provides"
+  })
+}).meta({
+  title: "External Link",
+  description: "External link with label and description"
+});
+var NftAttributeSchema = z.strictObject({
+  trait_type: z.string().max(50).meta({
+    title: "Trait Type",
+    description: "Name of the trait or attribute"
+  }),
+  value: z.union([z.string(), z.number(), z.boolean()]).meta({
+    title: "Trait Value",
+    description: "Value of the trait - can be string, number, or boolean"
+  }),
+  display_type: z.enum(["number", "date", "boost_number", "boost_percentage"]).optional().meta({
+    title: "Display Type",
+    description: "How the trait should be displayed in marketplace UIs"
+  }),
+  max_value: NonNegativeFloatSchema.optional().meta({
+    title: "Max Value",
+    description: "Maximum possible value for numeric traits"
+  })
+}).meta({
+  title: "NFT Attribute",
+  description: "NFT attribute or trait with type and value"
+});
+var NftIpfsSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: NftSchemaTypeSchema.meta({
+      title: "NFT Schema Type",
+      description: "Type/category of this NFT schema"
+    })
+  }),
+  blockchain: BlockchainReferenceSchema,
+  name: z.string().min(1).max(100).meta({
+    title: "NFT Name",
+    description: "Full display name for this NFT, including extra context",
+    examples: [
+      "MassID #123 \u2022 Organic \u2022 3.0t",
+      "RecycledID #456 \u2022 Plastic \u2022 2.5t",
+      "GasID #789 \u2022 Methane \u2022 1000 m\xB3"
+    ]
+  }),
+  short_name: z.string().min(1).max(50).meta({
+    title: "Short Name",
+    description: "Compact name for UI summaries, tables, or tooltips",
+    examples: ["MassID #123", "RecycledID #456", "GasID #789"]
+  }),
+  description: z.string().min(10).max(500).meta({
+    title: "Description",
+    description: "Human-readable summary of the NFT's role and context. Ideally, maximum 300 characters.",
+    examples: [
+      "This MassID represents 3 metric tons of organic food waste from Enlatados Produ\xE7\xE3o, tracked through complete chain of custody from generation to composting.",
+      "This RecycledID represents 2.5 metric tons of recycled plastic bottles processed by Green Solutions Ltd."
+    ]
+  }),
+  image: IpfsUriSchema.meta({
+    title: "Image URI",
+    description: "IPFS URI pointing to the preview image"
+  }),
+  background_color: HexColorSchema.optional().meta({
+    title: "Background Color",
+    description: "Hex color code for marketplace background display"
+  }),
+  animation_url: IpfsUriSchema.optional().meta({
+    title: "Animation URL",
+    description: "IPFS URI pointing to an animated or interactive media file",
+    examples: [
+      "ipfs://QmAnimation123/mass-id-animation.mp4",
+      "ipfs://QmInteractive456/recycled-visualization.webm"
+    ]
+  }),
+  external_links: uniqueBy(
+    ExternalLinkSchema,
+    (link) => link.url,
+    "External link URLs must be unique"
+  ).max(10).optional().meta({
+    title: "External Links",
+    description: "Optional list of public resource links with labels",
+    examples: [
+      [
+        {
+          label: "Carrot Explorer",
+          url: "https://explore.carrot.eco/document/ad44dd3f-f176-4b98-bf78-5ee6e77d0530",
+          description: "Complete chain of custody and audit trail"
+        },
+        {
+          label: "Carrot White Paper",
+          url: "https://carrot.eco/whitepaper.pdf",
+          description: "Carrot Foundation technical and impact white paper"
+        }
+      ]
+    ]
+  }),
+  attributes: uniqueBy(
+    NftAttributeSchema,
+    (attr) => attr.trait_type,
+    "Attribute trait_type values must be unique"
+  ).meta({
+    title: "NFT Attributes",
+    description: "List of visual traits and filterable attributes compatible with NFT marketplaces",
+    examples: [
+      [
+        {
+          trait_type: "Waste Type",
+          value: "Organic"
+        },
+        {
+          trait_type: "Waste Subtype",
+          value: "Food, Food Waste and Beverages"
+        },
+        {
+          trait_type: "Weight (kg)",
+          value: 3e3,
+          display_type: "number"
+        },
+        {
+          trait_type: "Origin Country",
+          value: "Brazil"
+        },
+        {
+          trait_type: "Pick-up Date",
+          value: "2024-12-05",
+          display_type: "date"
+        }
+      ]
+    ]
+  })
+}).meta({
+  title: "NFT IPFS Record",
+  description: "NFT-specific fields for Carrot IPFS records"
+});
+
+// src/mass-id/mass-id.schema.ts
+var AttributeWasteTypeSchema = z.strictObject({
+  trait_type: z.literal("Waste Type"),
+  value: WasteTypeSchema
+}).meta({
+  title: "Waste Type Attribute",
+  description: "Waste type attribute"
+});
+var AttributeWasteSubtypeSchema = z.strictObject({
+  trait_type: z.literal("Waste Subtype"),
+  value: WasteSubtypeSchema
+}).meta({
+  title: "Waste Subtype Attribute",
+  description: "Waste subtype attribute"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var 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"
+});
+var MassIDIpfsSchemaMeta = {
+  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.1"
+};
+var 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(MassIDIpfsSchemaMeta);
+
+export { MassIDDataSchema, MassIDIpfsSchema, MassIDIpfsSchemaMeta };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map