@carrot-foundation/schemas 0.1.20 → 0.1.22

package/schemas/ipfs/recycled-id/recycled-id.example.json

@@ -145,7 +145,7 @@
         "longitude": -51.07045,
         "precision_level": "city"
       },
-      "facility_type": "Waste Generation",
+      "facility_type": "Collection Point",
       "responsible_participant_id": "5021ea45-5b35-4749-8a85-83dc0c6f7cbf"
     },
     "accredited_participants": [

package/schemas/ipfs/shared/definitions/definitions.schema.json

@@ -112,18 +112,13 @@
     "facility_type": {
       "type": "string",
       "enum": [
-        "Waste Generation",
         "Collection Point",
-        "Transfer Station",
-        "Sorting Facility",
-        "Composting Facility",
         "Recycling Facility",
-        "Processing Facility",
-        "Disposal Facility",
-        "Administrative Office"
+        "Administrative Office",
+        "Other"
       ],
       "title": "Facility Type",
-      "description": "Type of facility at a location.",
+      "description": "Type of facility in the waste management chain.",
       "example": "Recycling Facility"
     },
     "chain_id": {

package/schemas/ipfs/shared/entities/location/location.schema.json

@@ -76,18 +76,13 @@
     "facility_type": {
       "type": "string",
       "enum": [
-        "Waste Generation",
         "Collection Point",
-        "Transfer Station",
-        "Sorting Facility",
-        "Composting Facility",
         "Recycling Facility",
-        "Processing Facility",
-        "Disposal Facility",
-        "Administrative Office"
+        "Administrative Office",
+        "Other"
       ],
       "title": "Facility Type",
-      "description": "Type of facility at a location.",
+      "description": "Type of facility in the waste management chain.",
       "example": "Recycling Facility"
     }
   },

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/dist/mass-id/index.d.ts

@@ -1,3 +0,0 @@
-export * from './mass-id.data.schema.js';
-export * from './mass-id.schema.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/mass-id/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mass-id/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

package/dist/mass-id/index.js

@@ -1,2 +0,0 @@
-export * from './mass-id.data.schema.js';
-export * from './mass-id.schema.js';

package/dist/mass-id/mass-id.data.schema.d.ts

@@ -1,256 +0,0 @@
-import { z } from 'zod';
-declare const MassIDLocalClassificationSchema: z.ZodObject<{
-    code: z.ZodString;
-    description: z.ZodString;
-    system: z.ZodString;
-}, z.core.$strict>;
-export type MassIDLocalClassification = z.infer<typeof MassIDLocalClassificationSchema>;
-declare const MassIDMeasurementUnitSchema: z.ZodEnum<{
-    kg: "kg";
-    ton: "ton";
-}>;
-export type MassIDMeasurementUnit = z.infer<typeof MassIDMeasurementUnitSchema>;
-declare const ContaminationLevelSchema: z.ZodEnum<{
-    None: "None";
-    Low: "Low";
-    Medium: "Medium";
-    High: "High";
-}>;
-export type ContaminationLevel = z.infer<typeof ContaminationLevelSchema>;
-declare const MassIDWasteClassificationSchema: z.ZodObject<{
-    primary_type: z.ZodString;
-    subtype: z.ZodString;
-    local_classification: z.ZodOptional<z.ZodObject<{
-        code: z.ZodString;
-        description: z.ZodString;
-        system: z.ZodString;
-    }, z.core.$strict>>;
-    measurement_unit: z.ZodEnum<{
-        kg: "kg";
-        ton: "ton";
-    }>;
-    net_weight: z.ZodNumber;
-    contamination_level: z.ZodOptional<z.ZodEnum<{
-        None: "None";
-        Low: "Low";
-        Medium: "Medium";
-        High: "High";
-    }>>;
-}, z.core.$strict>;
-export type MassIDWasteClassification = z.infer<typeof MassIDWasteClassificationSchema>;
-declare const EventAttributeFormatSchema: z.ZodEnum<{
-    KILOGRAM: "KILOGRAM";
-    DATE: "DATE";
-    CURRENCY: "CURRENCY";
-    PERCENTAGE: "PERCENTAGE";
-    COORDINATE: "COORDINATE";
-}>;
-export type EventAttributeFormat = z.infer<typeof EventAttributeFormatSchema>;
-declare const EventAttributeSchema: z.ZodObject<{
-    name: z.ZodString;
-    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-    format: z.ZodOptional<z.ZodEnum<{
-        KILOGRAM: "KILOGRAM";
-        DATE: "DATE";
-        CURRENCY: "CURRENCY";
-        PERCENTAGE: "PERCENTAGE";
-        COORDINATE: "COORDINATE";
-    }>>;
-}, z.core.$strict>;
-export type EventAttribute = z.infer<typeof EventAttributeSchema>;
-declare const EventDocumentSchema: z.ZodObject<{
-    type: z.ZodString;
-    document_number: z.ZodOptional<z.ZodString>;
-    reference: z.ZodString;
-    issue_date: z.ZodOptional<z.ZodISODate>;
-    issuer: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type EventDocumentation = z.infer<typeof EventDocumentSchema>;
-declare const MassIDChainOfCustodyEventSchema: z.ZodObject<{
-    event_id: z.ZodUUID;
-    event_name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    timestamp: z.ZodISODateTime;
-    participant_id: z.ZodUUID;
-    location_id: z.ZodUUID;
-    weight: z.ZodOptional<z.ZodNumber>;
-    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-        format: z.ZodOptional<z.ZodEnum<{
-            KILOGRAM: "KILOGRAM";
-            DATE: "DATE";
-            CURRENCY: "CURRENCY";
-            PERCENTAGE: "PERCENTAGE";
-            COORDINATE: "COORDINATE";
-        }>>;
-    }, z.core.$strict>>>;
-    documentation: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodString;
-        document_number: z.ZodOptional<z.ZodString>;
-        reference: z.ZodString;
-        issue_date: z.ZodOptional<z.ZodISODate>;
-        issuer: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    notes: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type MassIDChainOfCustodyEvent = z.infer<typeof MassIDChainOfCustodyEventSchema>;
-declare const MassIDChainOfCustodySchema: z.ZodObject<{
-    events: z.ZodArray<z.ZodObject<{
-        event_id: z.ZodUUID;
-        event_name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        timestamp: z.ZodISODateTime;
-        participant_id: z.ZodUUID;
-        location_id: z.ZodUUID;
-        weight: z.ZodOptional<z.ZodNumber>;
-        attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-            format: z.ZodOptional<z.ZodEnum<{
-                KILOGRAM: "KILOGRAM";
-                DATE: "DATE";
-                CURRENCY: "CURRENCY";
-                PERCENTAGE: "PERCENTAGE";
-                COORDINATE: "COORDINATE";
-            }>>;
-        }, z.core.$strict>>>;
-        documentation: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            type: z.ZodString;
-            document_number: z.ZodOptional<z.ZodString>;
-            reference: z.ZodString;
-            issue_date: z.ZodOptional<z.ZodISODate>;
-            issuer: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-        notes: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    total_distance_km: z.ZodNumber;
-    total_duration_hours: z.ZodNumber;
-}, z.core.$strict>;
-export type MassIDChainOfCustody = z.infer<typeof MassIDChainOfCustodySchema>;
-declare const MassIDTransportRouteSchema: z.ZodObject<{
-    from_location_id: z.ZodUUID;
-    to_location_id: z.ZodUUID;
-    distance_km: z.ZodNumber;
-    transport_method: z.ZodString;
-    duration_hours: z.ZodNumber;
-}, z.core.$strict>;
-export type MassIDTransportRoute = z.infer<typeof MassIDTransportRouteSchema>;
-declare const MassIDGeographicDataSchema: z.ZodObject<{
-    origin_location_id: z.ZodUUID;
-    processing_location_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-    final_destination_id: z.ZodUUID;
-    transport_routes: z.ZodArray<z.ZodObject<{
-        from_location_id: z.ZodUUID;
-        to_location_id: z.ZodUUID;
-        distance_km: z.ZodNumber;
-        transport_method: z.ZodString;
-        duration_hours: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type MassIDGeographicData = z.infer<typeof MassIDGeographicDataSchema>;
-export declare const MassIDDataSchema: z.ZodObject<{
-    waste_classification: z.ZodObject<{
-        primary_type: z.ZodString;
-        subtype: z.ZodString;
-        local_classification: z.ZodOptional<z.ZodObject<{
-            code: z.ZodString;
-            description: z.ZodString;
-            system: z.ZodString;
-        }, z.core.$strict>>;
-        measurement_unit: z.ZodEnum<{
-            kg: "kg";
-            ton: "ton";
-        }>;
-        net_weight: z.ZodNumber;
-        contamination_level: z.ZodOptional<z.ZodEnum<{
-            None: "None";
-            Low: "Low";
-            Medium: "Medium";
-            High: "High";
-        }>>;
-    }, z.core.$strict>;
-    locations: z.ZodArray<z.ZodObject<{
-        id: z.ZodUUID;
-        municipality: z.ZodString;
-        administrative_division: z.ZodString;
-        administrative_division_code: z.ZodOptional<z.ZodString>;
-        country: z.ZodString;
-        country_code: z.ZodString;
-        responsible_participant_id: z.ZodUUID;
-        coordinates: z.ZodObject<{
-            latitude: z.ZodNumber;
-            longitude: z.ZodNumber;
-            precision_level: z.ZodEnum<{
-                exact: "exact";
-                neighborhood: "neighborhood";
-                city: "city";
-                region: "region";
-                country: "country";
-            }>;
-        }, z.core.$strict>;
-        facility_type: z.ZodOptional<z.ZodEnum<{
-            "Waste Generation": "Waste Generation";
-            "Collection Point": "Collection Point";
-            "Transfer Station": "Transfer Station";
-            "Sorting Facility": "Sorting Facility";
-            "Composting Facility": "Composting Facility";
-            "Recycling Facility": "Recycling Facility";
-            "Processing Facility": "Processing Facility";
-            "Disposal Facility": "Disposal Facility";
-            "Administrative Office": "Administrative Office";
-        }>>;
-    }, z.core.$strict>>;
-    participants: z.ZodArray<z.ZodObject<{
-        id: z.ZodUUID;
-        name: z.ZodString;
-        roles: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-    chain_of_custody: z.ZodObject<{
-        events: z.ZodArray<z.ZodObject<{
-            event_id: z.ZodUUID;
-            event_name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            timestamp: z.ZodISODateTime;
-            participant_id: z.ZodUUID;
-            location_id: z.ZodUUID;
-            weight: z.ZodOptional<z.ZodNumber>;
-            attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-                format: z.ZodOptional<z.ZodEnum<{
-                    KILOGRAM: "KILOGRAM";
-                    DATE: "DATE";
-                    CURRENCY: "CURRENCY";
-                    PERCENTAGE: "PERCENTAGE";
-                    COORDINATE: "COORDINATE";
-                }>>;
-            }, z.core.$strict>>>;
-            documentation: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                type: z.ZodString;
-                document_number: z.ZodOptional<z.ZodString>;
-                reference: z.ZodString;
-                issue_date: z.ZodOptional<z.ZodISODate>;
-                issuer: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>>;
-            notes: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        total_distance_km: z.ZodNumber;
-        total_duration_hours: z.ZodNumber;
-    }, z.core.$strict>;
-    geographic_data: z.ZodObject<{
-        origin_location_id: z.ZodUUID;
-        processing_location_ids: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
-        final_destination_id: z.ZodUUID;
-        transport_routes: z.ZodArray<z.ZodObject<{
-            from_location_id: z.ZodUUID;
-            to_location_id: z.ZodUUID;
-            distance_km: z.ZodNumber;
-            transport_method: z.ZodString;
-            duration_hours: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type MassIDData = z.infer<typeof MassIDDataSchema>;
-export {};
-//# sourceMappingURL=mass-id.data.schema.d.ts.map

package/dist/mass-id/mass-id.data.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mass-id.data.schema.d.ts","sourceRoot":"","sources":["../../src/mass-id/mass-id.data.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,QAAA,MAAM,+BAA+B;;;;kBAiCjC,CAAC;AAEL,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,QAAA,MAAM,2BAA2B;;;EAI/B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,QAAA,MAAM,wBAAwB;;;;;EAM1B,CAAC;AAEL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,QAAA,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;kBAuBjC,CAAC;AAEL,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,QAAA,MAAM,0BAA0B;;;;;;EAM5B,CAAC;AAEL,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,QAAA,MAAM,oBAAoB;;;;;;;;;;kBAmCtB,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,QAAA,MAAM,mBAAmB;;;;;;kBA+DrB,CAAC;AACL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAErE,QAAA,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyDjC,CAAC;AAEL,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoB5B,CAAC;AAEL,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,QAAA,MAAM,0BAA0B;;;;;;kBAqC5B,CAAC;AAEL,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,QAAA,MAAM,0BAA0B;;;;;;;;;;;kBAuB5B,CAAC;AAEL,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8DzB,CAAC;AAEL,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

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

@@ -1,348 +0,0 @@
-import { z } from 'zod';
-import { UuidSchema, WasteTypeSchema, WasteSubtypeSchema, NonEmptyStringSchema, NonNegativeFloatSchema, IsoTimestampSchema, IsoDateSchema, HoursSchema, } from '../shared/definitions.schema.js';
-import { LocationSchema } from '../shared/entities/location.schema.js';
-import { ParticipantSchema } from '../shared/entities/participant.schema.js';
-import { uniqueBy } from '../shared/helpers.schema.js';
-const 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',
-});
-const MassIDMeasurementUnitSchema = z.enum(['kg', 'ton']).meta({
-    title: 'Measurement Unit',
-    description: 'Unit of measurement for the waste quantity',
-    examples: ['kg', 'ton'],
-});
-const ContaminationLevelSchema = z
-    .enum(['None', 'Low', 'Medium', 'High'])
-    .meta({
-    title: 'Contamination Level',
-    description: 'Level of contamination in the waste batch',
-    examples: ['Low', 'Medium', 'None'],
-});
-const 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',
-});
-const EventAttributeFormatSchema = z
-    .enum(['KILOGRAM', 'DATE', 'CURRENCY', 'PERCENTAGE', 'COORDINATE'])
-    .meta({
-    title: 'Event Attribute Format',
-    description: 'Data format hint for proper display',
-    examples: ['KILOGRAM', 'DATE', 'PERCENTAGE'],
-});
-const 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',
-});
-const 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',
-});
-const 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',
-});
-const 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',
-});
-const 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',
-});
-const 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',
-});
-export const 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',
-});