@carrot-foundation/schemas 0.1.39 → 0.1.40

package/dist/index.cjs

@@ -25,9 +25,7 @@ var EthereumAddressSchema = zod.z.string().regex(
     "0xabcdef1234567890abcdef1234567890abcdef12"
   ]
 });
-var IsoTimestampSchema = zod.z.iso.datetime({
-  message: "Must be a valid ISO 8601 timestamp with timezone"
-}).meta({
+var IsoTimestampSchema = zod.z.iso.datetime().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"]
@@ -141,29 +139,15 @@ var ParticipantNameSchema = NonEmptyStringSchema.max(100).meta({
   description: "Name of a participant in the waste management system",
   examples: ["Enlatados Produ\xE7\xE3o", "Eco Reciclagem", "Green Tech Corp"]
 });
-var FacilityTypeSchema = zod.z.enum([
-  "Collection Point",
-  "Recycling Facility",
-  "Administrative Office",
-  "Other"
-]).meta({
-  title: "Facility Type",
-  description: "Type of facility in the waste management chain",
-  examples: [
-    "Collection Point",
-    "Recycling Facility",
-    "Administrative Office"
-  ]
-});
 var BlockchainChainIdSchema = zod.z.number().int().min(1).meta({
   title: "Chain ID",
   description: "Blockchain network identifier",
-  examples: [1, 137, 11155111]
+  examples: [137, 80002]
 });
 var BlockchainNetworkNameSchema = NonEmptyStringSchema.max(100).meta({
   title: "Blockchain Network Name",
   description: "Name of the blockchain network",
-  examples: ["Polygon", "Ethereum mainnet", "Sepolia"]
+  examples: ["Polygon", "Amoy"]
 });
 var SmartContractAddressSchema = EthereumAddressSchema.meta({
   title: "Smart Contract Address",
@@ -394,8 +378,7 @@ var LocationSchema = zod.z.strictObject({
     title: "Responsible Participant ID Hash",
     description: "Anonymized ID of the participant responsible for this location"
   }),
-  coordinates: CoordinatesSchema,
-  facility_type: FacilityTypeSchema.optional()
+  coordinates: CoordinatesSchema
 }).meta({
   title: "Location",
   description: "Geographic location with address and coordinate information"
@@ -918,7 +901,7 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.39";
+  return "0.1.40";
 }
 var MethodologyAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Methodology"),
@@ -1418,6 +1401,294 @@ function validateAttributesForItems(params) {
     }
   });
 }
+var IbamaWasteClassificationSchema = zod.z.string().regex(/^\d{2} \d{2} \d{2}\*?$/, "Invalid Ibama code format").meta({
+  title: "Ibama Classification Code",
+  description: "Ibama waste classification code in the format NN NN NN with required spaces and optional trailing *",
+  examples: ["20 01 01", "20 01 01*", "04 02 20"]
+});
+var MassIDLocalClassificationSchema = zod.z.strictObject({
+  code: IbamaWasteClassificationSchema,
+  system: zod.z.literal("Ibama").meta({
+    title: "Classification System",
+    description: "Authority or standard providing the classification code",
+    examples: ["Ibama"]
+  })
+}).meta({
+  title: "Local Classification",
+  description: "Regulatory classification reference for the waste material",
+  examples: [{ code: "04 02 20", system: "Ibama" }]
+});
+var MassIDWastePropertiesSchema = zod.z.strictObject({
+  type: WasteTypeSchema.meta({
+    title: "Waste Type",
+    description: "Waste material category",
+    examples: ["Organic"]
+  }),
+  subtype: WasteSubtypeSchema.meta({
+    title: "Waste Subtype",
+    description: "Specific subcategory of waste material",
+    examples: ["Food, Food Waste and Beverages"]
+  }),
+  local_classification: MassIDLocalClassificationSchema.optional(),
+  net_weight: WeightKgSchema.meta({
+    title: "Net Weight (kg)",
+    description: "Net weight of the waste batch in kilograms (kg)",
+    examples: [3e3]
+  })
+}).meta({
+  title: "Waste Properties",
+  description: "Standardized waste material properties and regulatory information"
+});
+var MassIDAttachmentTypeSchema = zod.z.enum(["Recycling Manifest", "Transport Manifest"]).meta({
+  title: "Attachment Type",
+  description: "Type of supporting attachment linked to a MassID event",
+  examples: ["Recycling Manifest", "Transport Manifest"]
+});
+var MassIDAttachmentSchema = zod.z.strictObject({
+  type: MassIDAttachmentTypeSchema,
+  document_number: NonEmptyStringSchema.max(50).optional().meta({
+    title: "Document Number",
+    description: "Official document number if applicable",
+    examples: ["2353", "12345"]
+  }),
+  issued_at: IsoTimestampSchema.optional().meta({
+    title: "Issued At",
+    description: "ISO 8601 timestamp when the attachment was issued"
+  }),
+  event_id: UuidSchema.meta({
+    title: "Event ID",
+    description: "Identifier of the event this attachment belongs to"
+  })
+}).meta({
+  title: "MassID Attachment",
+  description: "Attachment associated with a specific MassID event, linked by event_id"
+});
+var MassIDBaseEventSchema = zod.z.strictObject({
+  event_id: UuidSchema.meta({
+    title: "Event ID",
+    description: "Unique event identifier"
+  }),
+  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",
+      "Waste transferred to authorized recycling facility"
+    ]
+  }),
+  timestamp: IsoTimestampSchema.meta({
+    title: "Event Timestamp",
+    description: "ISO 8601 timestamp when the event occurred"
+  }),
+  participant_id_hash: Sha256HashSchema.meta({
+    title: "Participant ID Hash",
+    description: "Reference to participant in the participants array"
+  }),
+  location_id_hash: Sha256HashSchema.meta({
+    title: "Location ID Hash",
+    description: "Reference to location in the locations array"
+  }),
+  weight: WeightKgSchema.optional().meta({
+    title: "Event Weight (kg)",
+    description: "Mass weight after this event in kilograms (kg)"
+  })
+}).meta({
+  title: "MassID Base Event",
+  description: "Base MassID event definition shared across event types"
+});
+var buildMassIDEventSchema = (eventName, description) => MassIDBaseEventSchema.safeExtend({
+  event_name: zod.z.literal(eventName).meta({
+    title: "Event Name",
+    description: `${eventName} event discriminator`,
+    examples: [eventName]
+  })
+}).meta({
+  title: `${eventName} Event`,
+  description
+});
+var PickUpEventSchema = buildMassIDEventSchema(
+  "Pick-up",
+  "Waste picked up from the origin location"
+).safeExtend({
+  data: zod.z.strictObject({
+    vehicle_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Vehicle Type",
+      description: "Type of vehicle used for pick-up operations",
+      examples: ["Truck", "Van", "Compactor"]
+    })
+  }).optional().meta({
+    title: "Pick-up Event Data",
+    description: "Vehicle information associated with the pick-up event"
+  })
+});
+var WeighingEventSchema = buildMassIDEventSchema(
+  "Weighing",
+  "Waste weighed at a facility"
+).safeExtend({
+  data: zod.z.strictObject({
+    weighing_capture_method: NonEmptyStringSchema.max(100).optional().meta({
+      title: "Weighing Capture Method",
+      description: "Method used to capture the weight measurement",
+      examples: [
+        "Digital scale integration",
+        "Manual entry",
+        "Automated capture via IoT scale"
+      ]
+    }),
+    scale_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Scale Type",
+      description: "Type of scale used to weigh the load",
+      examples: ["Weighbridge (Truck Scale)", "Axle scale"]
+    }),
+    container_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Container Type",
+      description: "Type of container holding the waste during weighing",
+      examples: ["Roll-off container", "Front loader bin"]
+    }),
+    vehicle_type: NonEmptyStringSchema.max(50).optional().meta({
+      title: "Vehicle Type",
+      description: "Type of vehicle used during weighing",
+      examples: ["Truck", "Trailer"]
+    }),
+    container_capacity: WeightKgSchema.optional().meta({
+      title: "Container Capacity (kg)",
+      description: "Maximum container capacity in kilograms",
+      examples: [12e3]
+    }),
+    gross_weight: WeightKgSchema.optional().meta({
+      title: "Gross Weight (kg)",
+      description: "Total weight including vehicle/container before tare",
+      examples: [9500]
+    }),
+    tare: WeightKgSchema.optional().meta({
+      title: "Tare Weight (kg)",
+      description: "Weight of the empty vehicle or container",
+      examples: [3500]
+    })
+  }).optional().meta({
+    title: "Weighing Event Data",
+    description: "Weighing operational details including capture method, equipment, and weights"
+  })
+});
+var DropOffEventSchema = buildMassIDEventSchema(
+  "Drop-off",
+  "Waste delivered to a destination location"
+);
+var SortingEventSchema = buildMassIDEventSchema(
+  "Sorting",
+  "Sorting or segregation of waste materials"
+).safeExtend({
+  data: zod.z.strictObject({
+    initial_weight: WeightKgSchema.optional().meta({
+      title: "Initial Weight (kg)",
+      description: "Weight of the material entering the sorting process in kilograms",
+      examples: [5e3]
+    }),
+    deducted_weight: WeightKgSchema.optional().meta({
+      title: "Deducted Weight (kg)",
+      description: "Weight removed during sorting (e.g., contaminants or moisture) in kilograms",
+      examples: [250]
+    })
+  }).optional().meta({
+    title: "Sorting Event Data",
+    description: "Weights associated with sorting, including initial and deducted amounts"
+  })
+});
+var RecyclingEventSchema = buildMassIDEventSchema(
+  "Recycling",
+  "Waste processed or recycled at the destination"
+);
+var MassIDEventSchema = zod.z.discriminatedUnion("event_name", [
+  PickUpEventSchema,
+  WeighingEventSchema,
+  DropOffEventSchema,
+  SortingEventSchema,
+  RecyclingEventSchema
+]).meta({
+  title: "MassID Event",
+  description: "Lifecycle event describing custody, processing, documentation, or recycling steps"
+});
+var MassIDEventsSchema = zod.z.array(MassIDEventSchema).min(1).superRefine((events, ctx) => {
+  events.forEach((event, index) => {
+    if (index === 0) {
+      return;
+    }
+    const previousEvent = events[index - 1];
+    if (event.timestamp < previousEvent.timestamp) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "timestamp"],
+        message: "Events must be ordered by timestamp"
+      });
+    }
+  });
+}).meta({
+  title: "MassID Events",
+  description: "Chronological sequence of custody transfer, processing, and recycling events"
+});
+var MassIDDataSchema = zod.z.strictObject({
+  waste_properties: MassIDWastePropertiesSchema,
+  locations: uniqueBy(
+    LocationSchema,
+    (loc) => loc.id_hash,
+    "Location ID hashes must be unique"
+  ).min(1).meta({
+    title: "Locations",
+    description: "All locations referenced in this MassID, indexed by ID"
+  }),
+  participants: uniqueBy(
+    ParticipantSchema,
+    (participant) => participant.id_hash,
+    "Participant ID hashes must be unique"
+  ).min(1).meta({
+    title: "Participants",
+    description: "All participants referenced in this MassID, indexed by ID"
+  }),
+  events: MassIDEventsSchema,
+  attachments: zod.z.array(MassIDAttachmentSchema).optional().meta({
+    title: "Attachments",
+    description: "Supporting documents associated with events, linked by event_id"
+  })
+}).refine((data) => {
+  const participantIdSet = new Set(
+    data.participants.map((participant) => participant.id_hash)
+  );
+  const eventParticipantIds = data.events.map(
+    (event) => event.participant_id_hash
+  );
+  const allEventParticipantsExist = eventParticipantIds.every(
+    (participantId) => participantIdSet.has(participantId)
+  );
+  return allEventParticipantsExist;
+}, "All participant ID hashes in events must exist in participants array").refine((data) => {
+  const locationIdSet = new Set(
+    data.locations.map((location) => location.id_hash)
+  );
+  const eventLocationIds = data.events.map((event) => event.location_id_hash);
+  const allEventLocationsExist = eventLocationIds.every(
+    (locationId) => locationIdSet.has(locationId)
+  );
+  return allEventLocationsExist;
+}, "All location ID hashes in events must exist in locations array").refine((data) => {
+  if (!data.attachments || data.attachments.length === 0) {
+    return true;
+  }
+  const eventIdSet = new Set(data.events.map((event) => event.event_id));
+  return data.attachments.every(
+    (attachment) => eventIdSet.has(attachment.event_id)
+  );
+}, "All attachments must reference an existing event by event_id").refine((data) => {
+  const participantIdSet = new Set(
+    data.participants.map((participant) => participant.id_hash)
+  );
+  return data.locations.every(
+    (location) => participantIdSet.has(location.responsible_participant_id_hash)
+  );
+}, "All responsible participant ID hashes in locations must exist in participants array").meta({
+  title: "MassID Data",
+  description: "MassID data containing waste tracking events and supporting information"
+});
 
 // src/mass-id/mass-id.attributes.ts
 var MassIDAttributeWasteTypeSchema = NftAttributeSchema.safeExtend({
@@ -1425,22 +1696,22 @@ var MassIDAttributeWasteTypeSchema = NftAttributeSchema.safeExtend({
   value: WasteTypeSchema
 }).meta({
   title: "Waste Type Attribute",
-  description: "Waste type attribute"
+  description: "Primary waste material category (e.g., Organic, Paper, Glass, Metal)"
 });
 var MassIDAttributeWasteSubtypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Waste Subtype"),
   value: WasteSubtypeSchema
 }).meta({
   title: "Waste Subtype Attribute",
-  description: "Waste subtype attribute"
+  description: "Regulatory or operational waste subtype (e.g., Food, Food Waste and Beverages)"
 });
 var MassIDAttributeWeightSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weight (kg)"),
   value: WeightKgSchema,
   display_type: zod.z.literal("number")
 }).meta({
-  title: "Weight Attribute",
-  description: "Weight attribute with numeric display"
+  title: "Weight Attribute (kg)",
+  description: "Net batch weight in kilograms (kg) for this MassID"
 });
 var MassIDAttributeOriginCountrySchema = OriginCountryAttributeSchema.safeExtend({
   value: CountryNameSchema
@@ -1453,84 +1724,70 @@ var MassIDAttributeOriginDivisionSchema = NftAttributeSchema.safeExtend({
   value: AdministrativeDivisionSchema
 }).meta({
   title: "Origin Administrative Division Attribute",
-  description: "Origin administrative division attribute"
+  description: "State/province where the waste was generated (ISO 3166-2 preferred)"
 });
-var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Vehicle Type"),
+var MassIDAttributePickUpVehicleTypeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Pick-up Vehicle Type"),
   value: NonEmptyStringSchema.max(100).meta({
-    title: "Vehicle Type",
-    description: "Type of vehicle used for waste transportation",
-    examples: ["Garbage Truck", "Box Truck", "Flatbed Truck", "Roll-off Truck"]
+    title: "Pick-up Vehicle Type",
+    description: "Type of vehicle used for waste pick-up operations",
+    examples: ["Truck", "Box Truck", "Flatbed Truck", "Roll-off Truck"]
   })
 }).meta({
-  title: "Vehicle Type Attribute",
-  description: "Vehicle type attribute"
+  title: "Pick-up Vehicle Type Attribute",
+  description: "Vehicle type used during pick-up"
 });
 var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycling Method",
     description: "Method used for recycling or processing the waste",
-    examples: [
-      "Composting",
-      "Mechanical Recycling",
-      "Incineration with Energy Recovery"
-    ]
+    examples: ["Composting", "Mechanical Recycling", "Anaerobic Digestion"]
   })
 }).meta({
   title: "Recycling Method Attribute",
-  description: "Recycling method attribute"
-});
-var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Processing Time (hours)"),
-  value: HoursSchema,
-  trait_description: NonEmptyStringSchema.max(200).optional().meta({
-    title: "Processing Time Description",
-    description: "Custom description for the processing time"
-  })
-}).meta({
-  title: "Processing Time Attribute",
-  description: "Processing time attribute with optional trait description"
+  description: "Process applied to this mass (e.g., composting, mechanical recycling)"
 });
 var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Local Waste Classification ID"),
-  value: NonEmptyStringSchema.max(100).meta({
-    title: "Local Waste Classification ID",
-    description: "Local or regional waste classification identifier",
-    examples: ["04 02 20", "IBAMA-A001", "EWC-150101"]
-  })
+  value: IbamaWasteClassificationSchema
 }).meta({
   title: "Local Waste Classification ID Attribute",
-  description: "Local waste classification ID attribute"
+  description: "Regulatory waste classification code (e.g., Ibama format NN NN NN[*])",
+  examples: ["20 01 01", "20 01 01*", "04 02 20"]
 });
 var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Recycling Manifest Code"),
+  trait_type: zod.z.literal("Recycling Manifest Number"),
   value: NonEmptyStringSchema.max(100).meta({
-    title: "Recycling Manifest Code",
-    description: "Concatenated recycling manifest code (Document Type + Document Number)",
-    examples: ["CDF-2353", "RC-12345", "REC-MANIFEST-789"]
+    title: "Recycling Manifest Number",
+    description: "Official recycling manifest identifier",
+    examples: ["2353", "REC-MANIFEST-789", "RC12345"]
   })
 }).meta({
-  title: "Recycling Manifest Code Attribute",
-  description: "Recycling manifest code attribute (optional)"
+  title: "Recycling Manifest Number Attribute",
+  description: "Official recycling manifest number issued by recycling authority (optional)"
 });
 var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Transport Manifest Code"),
+  trait_type: zod.z.literal("Transport Manifest Number"),
   value: NonEmptyStringSchema.max(100).meta({
-    title: "Transport Manifest Code",
-    description: "Concatenated transport manifest code (Document Type + Document Number)",
-    examples: ["MTR-4126", "TRN-67890", "TRANS-MANIFEST-456"]
+    title: "Transport Manifest Number",
+    description: "Official transport manifest identifier",
+    examples: ["4126", "TRN-67890", "TRANS-MANIFEST-456"]
   })
 }).meta({
-  title: "Transport Manifest Code Attribute",
-  description: "Transport manifest code attribute (optional)"
+  title: "Transport Manifest Number Attribute",
+  description: "Official transport manifest number issued by logistics/transport authority (optional)"
 });
 var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weighing Capture Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Weighing Capture Method",
     description: "Method used to capture weight data",
-    examples: ["Digital", "Manual", "Automated", "Electronic Scale"]
+    examples: [
+      "Digital scale integration",
+      "Manual entry",
+      "Automated capture via IoT scale"
+    ]
   })
 }).meta({
   title: "Weighing Capture Method Attribute",
@@ -1543,8 +1800,8 @@ var MassIDAttributeScaleTypeSchema = NftAttributeSchema.safeExtend({
     description: "Type of scale used for weighing",
     examples: [
       "Weighbridge (Truck Scale)",
+      "Axle scale",
       "Floor Scale",
-      "Bench Scale",
       "Crane Scale"
     ]
   })
@@ -1552,35 +1809,36 @@ var MassIDAttributeScaleTypeSchema = NftAttributeSchema.safeExtend({
   title: "Scale Type Attribute",
   description: "Scale type attribute (optional)"
 });
-var MassIDAttributeContainerTypeSchema = NftAttributeSchema.safeExtend({
-  trait_type: zod.z.literal("Container Type"),
-  value: NonEmptyStringSchema.max(100).meta({
-    title: "Container Type",
-    description: "Type of container used for waste storage or transport",
-    examples: ["Truck", "Dumpster", "Roll-off Container", "Compactor", "Bin"]
-  })
-}).meta({
-  title: "Container Type Attribute",
-  description: "Container type attribute (optional)"
-});
 var MassIDAttributePickUpDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Pick-up Date"),
   value: UnixTimestampSchema.meta({
     title: "Pick-up Date",
     description: "Unix timestamp in milliseconds when the waste was picked up from the source",
-    examples: [17105184e5, 17040672e5, 17152704e5]
+    examples: [1733396567e3]
   }),
   display_type: zod.z.literal("date")
 }).meta({
   title: "Pick-up Date Attribute",
   description: "Pick-up date attribute with Unix timestamp"
 });
+var MassIDAttributeDropOffDateSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Drop-off Date"),
+  value: UnixTimestampSchema.meta({
+    title: "Drop-off Date",
+    description: "Unix timestamp in milliseconds when the waste was dropped off at the destination",
+    examples: [1733407367e3]
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "Drop-off Date Attribute",
+  description: "Drop-off date attribute with Unix timestamp"
+});
 var MassIDAttributeRecyclingDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Date"),
   value: UnixTimestampSchema.meta({
     title: "Recycling Date",
     description: "Unix timestamp in milliseconds when the waste was recycled/processed",
-    examples: [17106048e5, 17041536e5, 17153568e5]
+    examples: [1733657567e3]
   }),
   display_type: zod.z.literal("date")
 }).meta({
@@ -1595,308 +1853,24 @@ var MassIDAttributesSchema = uniqueBy(
     MassIDAttributeOriginCountrySchema,
     MassIDAttributeOriginMunicipalitySchema,
     MassIDAttributeOriginDivisionSchema,
-    MassIDAttributeVehicleTypeSchema,
+    MassIDAttributePickUpVehicleTypeSchema,
     MassIDAttributeRecyclingMethodSchema,
-    MassIDAttributeProcessingTimeSchema,
     MassIDAttributeLocalWasteClassificationIdSchema,
     MassIDAttributeRecyclingManifestCodeSchema,
     MassIDAttributeTransportManifestCodeSchema,
     MassIDAttributeWeighingCaptureMethodSchema,
     MassIDAttributeScaleTypeSchema,
-    MassIDAttributeContainerTypeSchema,
     MassIDAttributePickUpDateSchema,
+    MassIDAttributeDropOffDateSchema,
     MassIDAttributeRecyclingDateSchema
   ]),
   (attr) => attr.trait_type
-).min(12).max(17).meta({
+).min(11).max(16).meta({
   title: "MassID Attributes",
-  description: "MassID NFT attributes array containing attributes selected from the available attribute types. The schema validates array length but does not enforce which specific attributes must be present."
-});
-var MassIDLocalClassificationSchema = zod.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: zod.z.enum(["IBAMA"]).meta({
-    title: "Classification System",
-    description: "Classification system name - currently supports IBAMA (Instituto Brasileiro do Meio Ambiente e dos Recursos Naturais Renov\xE1veis)",
-    examples: ["IBAMA"]
-  })
-}).meta({
-  title: "Local Classification",
-  description: "Local or regional waste classification codes and descriptions"
-});
-var MassIDMeasurementUnitSchema = zod.z.enum(["kg", "ton"]).meta({
-  title: "Measurement Unit",
-  description: "Unit of measurement for the waste quantity",
-  examples: ["kg", "ton"]
-});
-var MassIDWastePropertiesSchema = zod.z.strictObject({
-  type: WasteTypeSchema.meta({
-    title: "Waste Type",
-    description: "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"
-  })
-}).meta({
-  title: "Waste Properties",
-  description: "Standardized waste material properties and regulatory information"
-});
-var EventAttributeFormatSchema = zod.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 = zod.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: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]).optional().meta({
-    title: "Attribute Value",
-    description: "Event attribute value",
-    examples: [
-      25.5,
-      "Grade A",
-      true,
-      "BATCH-2024-001",
-      12.75,
-      "Shredder-X200",
-      false,
-      "OP-456"
-    ]
-  }),
-  preserved_sensitivity: zod.z.boolean().optional().meta({
-    title: "Preserved Sensitivity",
-    description: "Indicates if the attribute contains sensitive information that was preserved"
-  }),
-  format: EventAttributeFormatSchema.optional()
-}).meta({
-  title: "Event Attribute",
-  description: "Additional attribute specific to an event"
-});
-var EventAttachmentSchema = zod.z.strictObject({
-  type: NonEmptyStringSchema.max(50).meta({
-    title: "Attachment Type",
-    description: "Type of supporting attachment",
-    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: "Attachment Reference",
-    description: "Reference to attachment (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_timestamp: UnixTimestampSchema.optional().meta({
-    title: "Issue Timestamp",
-    description: "Unix timestamp in milliseconds when the attachment was issued",
-    examples: [17105184e5, 17040672e5, 17152704e5]
-  }),
-  issuer: NonEmptyStringSchema.max(100).optional().meta({
-    title: "Attachment Issuer",
-    description: "Entity that issued the attachment",
-    examples: [
-      "Environmental Protection Agency",
-      "Waste Management Solutions Ltd",
-      "Green Recycling Corp",
-      "City Waste Authority",
-      "EcoProcess Industries",
-      "Regional Environmental Office"
-    ]
-  })
-}).meta({
-  title: "Event Attachment",
-  description: "Supporting event attachment"
-});
-var MassIDChainOfCustodyEventSchema = zod.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: UnixTimestampSchema.meta({
-    title: "Event Timestamp",
-    description: "Unix timestamp in milliseconds when the event occurred",
-    examples: [17105184e5, 17040672e5, 17152704e5]
-  }),
-  participant_id_hash: Sha256HashSchema.meta({
-    title: "Participant ID Hash",
-    description: "Reference to participant in the participants array"
-  }),
-  location_id_hash: Sha256HashSchema.meta({
-    title: "Location ID Hash",
-    description: "Reference to location in the locations array"
-  }),
-  weight: NonNegativeFloatSchema.optional().meta({
-    title: "Event Weight",
-    description: "Mass weight after this event"
-  }),
-  attributes: zod.z.array(EventAttributeSchema).optional().meta({
-    title: "Event Attributes",
-    description: "Additional attributes specific to this event"
-  }),
-  attachments: zod.z.array(EventAttachmentSchema).optional().meta({
-    title: "Event Attachments",
-    description: "Associated attachments for this event"
-  })
-}).meta({
-  title: "Chain of Custody Event",
-  description: "Chain of custody event"
-});
-var MassIDChainOfCustodySchema = zod.z.strictObject({
-  events: zod.z.array(MassIDChainOfCustodyEventSchema).min(1).meta({
-    title: "Custody Events",
-    description: "Chronological sequence of custody transfer and processing events"
-  }),
-  total_duration_minutes: MinutesSchema.meta({
-    title: "Total Duration (minutes)",
-    description: "Total time from first to last event in minutes"
-  })
-}).meta({
-  title: "Chain of Custody",
-  description: "Complete chain of custody tracking from waste generation to final processing"
-});
-var MassIDGeographicDataSchema = zod.z.strictObject({
-  from_location_id_hash: Sha256HashSchema.meta({
-    title: "From Location ID Hash",
-    description: "Reference hash of the location where the waste started movement"
-  }),
-  to_location_id_hash: Sha256HashSchema.meta({
-    title: "To Location ID Hash",
-    description: "Reference hash of the location where the waste ended movement"
-  }),
-  first_reported_timestamp: UnixTimestampSchema.meta({
-    title: "First Reported Timestamp",
-    description: "Unix timestamp in milliseconds when the waste was first reported/collected at the origin location",
-    examples: [17105184e5, 17040672e5, 17152704e5]
-  }),
-  last_reported_timestamp: UnixTimestampSchema.meta({
-    title: "Last Reported Timestamp",
-    description: "Unix timestamp in milliseconds when the waste was last reported/processed at the destination location",
-    examples: [17106048e5, 17041536e5, 17153568e5]
-  })
-}).refine((data) => {
-  return data.first_reported_timestamp <= data.last_reported_timestamp;
-}, "first_reported_timestamp must be before or equal to last_reported_timestamp").meta({
-  title: "Geographic Data",
-  description: "Simplified geographic information tracking waste movement from origin to destination with temporal bounds"
-});
-var MassIDDataSchema = zod.z.strictObject({
-  waste_properties: MassIDWastePropertiesSchema,
-  locations: uniqueBy(
-    LocationSchema,
-    (loc) => loc.id_hash,
-    "Location ID hashes must be unique"
-  ).min(1).meta({
-    title: "Locations",
-    description: "All locations referenced in this MassID, indexed by ID"
-  }),
-  participants: uniqueBy(
-    ParticipantSchema,
-    (p) => p.id_hash,
-    "Participant ID hashes 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_hash)
-  );
-  const eventParticipantIds = data.chain_of_custody.events.map(
-    (event) => event.participant_id_hash
-  );
-  const allEventParticipantsExist = eventParticipantIds.every(
-    (participantId) => participantIdSet.has(participantId)
-  );
-  return allEventParticipantsExist;
-}, "All participant ID hashes in chain of custody events must exist in participants array").refine((data) => {
-  const locationIdSet = new Set(
-    data.locations.map((location) => location.id_hash)
-  );
-  const eventLocationIds = data.chain_of_custody.events.map(
-    (event) => event.location_id_hash
-  );
-  const allEventLocationsExist = eventLocationIds.every(
-    (locationId) => locationIdSet.has(locationId)
-  );
-  return allEventLocationsExist;
-}, "All location ID hashes 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"
+  description: "MassID NFT attributes array. Provide the canonical set covering waste (type, subtype, net weight), origin (country, municipality, administrative division), logistics (vehicle, manifests, weighing method/scale), and lifecycle timestamps (pick-up, drop-off, recycling). Length is validated; specific composition is producer-controlled."
 });
+var isPickUpEvent = (event) => event.event_name === "Pick-up";
+var isWeighingEvent = (event) => event.event_name === "Weighing";
 var MassIDIpfsSchemaMeta = {
   title: "MassID NFT IPFS Record",
   description: "Complete MassID NFT IPFS record including fixed attributes and detailed waste tracking data",
@@ -1912,6 +1886,148 @@ var MassIDIpfsSchema = NftIpfsSchema.safeExtend({
   }),
   attributes: MassIDAttributesSchema,
   data: MassIDDataSchema
+}).superRefine((record, ctx) => {
+  const { data, attributes } = record;
+  const findAttribute = (traitType) => {
+    const index = attributes.findIndex(
+      (attribute) => attribute.trait_type === traitType
+    );
+    return {
+      attribute: index >= 0 ? attributes[index] : void 0,
+      index
+    };
+  };
+  const assertAttributeMatches = (traitType, expectedValue, sourceDescription) => {
+    const { attribute, index } = findAttribute(traitType);
+    if (expectedValue === void 0 || expectedValue === null) {
+      if (attribute) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["attributes", index],
+          message: `${traitType} attribute must be omitted when ${sourceDescription} is not provided`
+        });
+      }
+      return;
+    }
+    if (!attribute) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["attributes"],
+        message: `${traitType} attribute must be present and match ${sourceDescription}`
+      });
+      return;
+    }
+    if (attribute.value !== expectedValue) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["attributes", index, "value"],
+        message: `${traitType} attribute must equal ${sourceDescription}`
+      });
+    }
+  };
+  const assertTimestampAttributeMatches = (traitType, isoTimestamp, sourceDescription) => {
+    if (!isoTimestamp) {
+      assertAttributeMatches(traitType, void 0, sourceDescription);
+      return;
+    }
+    const timestamp = Date.parse(isoTimestamp);
+    if (Number.isNaN(timestamp)) {
+      return;
+    }
+    assertAttributeMatches(traitType, timestamp, sourceDescription);
+  };
+  assertAttributeMatches(
+    "Waste Type",
+    data.waste_properties.type,
+    "waste_properties.type"
+  );
+  assertAttributeMatches(
+    "Waste Subtype",
+    data.waste_properties.subtype,
+    "waste_properties.subtype"
+  );
+  assertAttributeMatches(
+    "Weight (kg)",
+    data.waste_properties.net_weight,
+    "waste_properties.net_weight"
+  );
+  assertAttributeMatches(
+    "Local Waste Classification ID",
+    data.waste_properties.local_classification?.code,
+    "waste_properties.local_classification.code"
+  );
+  const pickUpEvent = data.events.find(isPickUpEvent);
+  const pickUpLocation = pickUpEvent ? data.locations.find(
+    (location) => location.id_hash === pickUpEvent.location_id_hash
+  ) : void 0;
+  assertAttributeMatches(
+    "Origin Country",
+    pickUpLocation?.country,
+    "Pick-up event location.country"
+  );
+  assertAttributeMatches(
+    "Origin Municipality",
+    pickUpLocation?.municipality,
+    "Pick-up event location.municipality"
+  );
+  assertAttributeMatches(
+    "Origin Administrative Division",
+    pickUpLocation?.administrative_division,
+    "Pick-up event location.administrative_division"
+  );
+  assertTimestampAttributeMatches(
+    "Pick-up Date",
+    pickUpEvent?.timestamp,
+    "Pick-up event timestamp"
+  );
+  assertAttributeMatches(
+    "Pick-up Vehicle Type",
+    pickUpEvent?.data?.vehicle_type,
+    "Pick-up event vehicle_type"
+  );
+  const dropOffEvent = data.events.find(
+    (event) => event.event_name === "Drop-off"
+  );
+  assertTimestampAttributeMatches(
+    "Drop-off Date",
+    dropOffEvent?.timestamp,
+    "Drop-off event timestamp"
+  );
+  const recyclingEvent = data.events.find(
+    (event) => event.event_name === "Recycling"
+  );
+  assertTimestampAttributeMatches(
+    "Recycling Date",
+    recyclingEvent?.timestamp,
+    "Recycling event timestamp"
+  );
+  const weighingEvent = data.events.find(isWeighingEvent);
+  assertAttributeMatches(
+    "Weighing Capture Method",
+    weighingEvent?.data?.weighing_capture_method,
+    "Weighing event weighing_capture_method"
+  );
+  assertAttributeMatches(
+    "Scale Type",
+    weighingEvent?.data?.scale_type,
+    "Weighing event scale_type"
+  );
+  const recyclingManifest = data.attachments?.find(
+    (attachment) => attachment.type === "Recycling Manifest" && attachment.document_number
+  );
+  assertAttributeMatches(
+    "Recycling Manifest Number",
+    recyclingManifest?.document_number,
+    "Recycling Manifest attachment document_number"
+  );
+  const transportManifest = data.attachments?.find(
+    (attachment) => attachment.type === "Transport Manifest" && attachment.document_number
+  );
+  assertAttributeMatches(
+    "Transport Manifest Number",
+    transportManifest?.document_number,
+    "Transport Manifest attachment document_number"
+  );
 }).meta(MassIDIpfsSchemaMeta);
 var GasIDAttributeMethodologySchema = MethodologyAttributeSchema;
 var GasIDAttributeGasTypeSchema = NftAttributeSchema.safeExtend({
@@ -3431,7 +3547,6 @@ exports.EPSILON = EPSILON;
 exports.EthereumAddressSchema = EthereumAddressSchema;
 exports.ExternalIdSchema = ExternalIdSchema;
 exports.ExternalUrlSchema = ExternalUrlSchema;
-exports.FacilityTypeSchema = FacilityTypeSchema;
 exports.GasIDAttributesSchema = GasIDAttributesSchema;
 exports.GasIDDataSchema = GasIDDataSchema;
 exports.GasIDIpfsSchema = GasIDIpfsSchema;
@@ -3439,6 +3554,7 @@ exports.GasIDIpfsSchemaMeta = GasIDIpfsSchemaMeta;
 exports.GasIDReferenceSchema = GasIDReferenceSchema;
 exports.HexColorSchema = HexColorSchema;
 exports.HoursSchema = HoursSchema;
+exports.IbamaWasteClassificationSchema = IbamaWasteClassificationSchema;
 exports.IpfsUriSchema = IpfsUriSchema;
 exports.IsoAdministrativeDivisionCodeSchema = IsoAdministrativeDivisionCodeSchema;
 exports.IsoCountryCodeSchema = IsoCountryCodeSchema;