@carrot-foundation/schemas 0.1.20 → 0.1.21

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',
-});

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

@@ -1,297 +0,0 @@
-import { z } from 'zod';
-declare const AttributeWasteTypeSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Waste Type">;
-    value: z.ZodString;
-}, z.core.$strict>;
-export type AttributeWasteType = z.infer<typeof AttributeWasteTypeSchema>;
-declare const AttributeWasteSubtypeSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Waste Subtype">;
-    value: z.ZodString;
-}, z.core.$strict>;
-export type AttributeWasteSubtype = z.infer<typeof AttributeWasteSubtypeSchema>;
-declare const AttributeWeightSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Weight (kg)">;
-    value: z.ZodNumber;
-    display_type: z.ZodLiteral<"number">;
-}, z.core.$strict>;
-export type AttributeWeight = z.infer<typeof AttributeWeightSchema>;
-declare const AttributeOriginCountrySchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Origin Country">;
-    value: z.ZodString;
-}, z.core.$strict>;
-export type AttributeOriginCountry = z.infer<typeof AttributeOriginCountrySchema>;
-declare const AttributeOriginMunicipalitySchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Origin Municipality">;
-    value: z.ZodString;
-}, z.core.$strict>;
-export type AttributeOriginMunicipality = z.infer<typeof AttributeOriginMunicipalitySchema>;
-declare const AttributeOriginDivisionSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Origin Administrative Division">;
-    value: z.ZodString;
-}, z.core.$strict>;
-export type AttributeOriginDivision = z.infer<typeof AttributeOriginDivisionSchema>;
-declare const AttributeRecyclerSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Recycler">;
-    value: z.ZodString;
-}, z.core.$strict>;
-export type AttributeRecycler = z.infer<typeof AttributeRecyclerSchema>;
-declare const AttributeIntegratorSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Integrator">;
-    value: z.ZodString;
-}, z.core.$strict>;
-export type AttributeIntegrator = z.infer<typeof AttributeIntegratorSchema>;
-declare const AttributePickUpDateSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Pick-up Date">;
-    value: z.ZodString;
-    display_type: z.ZodLiteral<"date">;
-}, z.core.$strict>;
-export type AttributePickUpDate = z.infer<typeof AttributePickUpDateSchema>;
-declare const AttributeRecyclingDateSchema: z.ZodObject<{
-    trait_type: z.ZodLiteral<"Recycling Date">;
-    value: z.ZodString;
-    display_type: z.ZodLiteral<"date">;
-}, z.core.$strict>;
-export type AttributeRecyclingDate = z.infer<typeof AttributeRecyclingDateSchema>;
-declare const MassIDAttributesSchema: z.ZodTuple<[z.ZodObject<{
-    trait_type: z.ZodLiteral<"Waste Type">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Waste Subtype">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Weight (kg)">;
-    value: z.ZodNumber;
-    display_type: z.ZodLiteral<"number">;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Origin Country">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Origin Municipality">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Origin Administrative Division">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Recycler">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Integrator">;
-    value: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Pick-up Date">;
-    value: z.ZodString;
-    display_type: z.ZodLiteral<"date">;
-}, z.core.$strict>, z.ZodObject<{
-    trait_type: z.ZodLiteral<"Recycling Date">;
-    value: z.ZodString;
-    display_type: z.ZodLiteral<"date">;
-}, z.core.$strict>], null>;
-export type MassIDAttributes = z.infer<typeof MassIDAttributesSchema>;
-export declare const MassIDIpfsSchemaMeta: {
-    readonly title: "MassID NFT IPFS Record";
-    readonly description: "Complete MassID NFT IPFS record including fixed attributes and detailed waste tracking data";
-    readonly $id: "https://raw.githubusercontent.com/carrot-foundation/schemas/refs/heads/main/schemas/ipfs/mass-id/mass-id.schema.json";
-    readonly version: "1.0.1";
-};
-export declare const MassIDIpfsSchema: z.ZodObject<{
-    $schema: z.ZodURL;
-    created_at: z.ZodISODateTime;
-    external_id: z.ZodUUID;
-    external_url: z.ZodURL;
-    original_content_hash: z.ZodCustomStringFormat<"sha256_hex">;
-    content_hash: z.ZodCustomStringFormat<"sha256_hex">;
-    creator: z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        id: z.ZodUUID;
-    }, z.core.$strict>>;
-    relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        target_uri: z.ZodString;
-        type: z.ZodEnum<{
-            collection: "collection";
-            credit: "credit";
-            "gas-id": "gas-id";
-            "mass-id": "mass-id";
-            "mass-id-audit": "mass-id-audit";
-            methodology: "methodology";
-            "purchase-id": "purchase-id";
-            "recycled-id": "recycled-id";
-        }>;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    environment: z.ZodOptional<z.ZodObject<{
-        blockchain_network: z.ZodEnum<{
-            mainnet: "mainnet";
-            testnet: "testnet";
-        }>;
-        deployment: z.ZodEnum<{
-            production: "production";
-            development: "development";
-            testing: "testing";
-        }>;
-        data_set_name: z.ZodEnum<{
-            TEST: "TEST";
-            PROD: "PROD";
-        }>;
-    }, z.core.$strict>>;
-    blockchain: z.ZodObject<{
-        smart_contract_address: z.ZodString;
-        chain_id: z.ZodNumber;
-        network_name: z.ZodString;
-        token_id: z.ZodString;
-    }, z.core.$strict>;
-    name: z.ZodString;
-    short_name: z.ZodString;
-    description: z.ZodString;
-    image: z.ZodString;
-    background_color: z.ZodOptional<z.ZodString>;
-    animation_url: z.ZodOptional<z.ZodString>;
-    external_links: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        url: z.ZodURL;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    schema: z.ZodObject<{
-        hash: z.ZodCustomStringFormat<"sha256_hex">;
-        version: z.ZodString;
-        type: z.ZodLiteral<"MassID">;
-    }, z.core.$strict>;
-    attributes: z.ZodTuple<[z.ZodObject<{
-        trait_type: z.ZodLiteral<"Waste Type">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Waste Subtype">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Weight (kg)">;
-        value: z.ZodNumber;
-        display_type: z.ZodLiteral<"number">;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Origin Country">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Origin Municipality">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Origin Administrative Division">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Recycler">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Integrator">;
-        value: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Pick-up Date">;
-        value: z.ZodString;
-        display_type: z.ZodLiteral<"date">;
-    }, z.core.$strict>, z.ZodObject<{
-        trait_type: z.ZodLiteral<"Recycling Date">;
-        value: z.ZodString;
-        display_type: z.ZodLiteral<"date">;
-    }, z.core.$strict>], null>;
-    data: 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>;
-}, z.core.$strict>;
-export type MassIDIpfs = z.infer<typeof MassIDIpfsSchema>;
-export {};
-//# sourceMappingURL=mass-id.schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mass-id.schema.d.ts","sourceRoot":"","sources":["../../src/mass-id/mass-id.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,QAAA,MAAM,wBAAwB;;;kBAQ1B,CAAC;AAEL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,QAAA,MAAM,2BAA2B;;;kBAQ7B,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,QAAA,MAAM,qBAAqB;;;;kBASvB,CAAC;AAEL,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,QAAA,MAAM,4BAA4B;;;kBAW9B,CAAC;AAEL,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,QAAA,MAAM,iCAAiC;;;kBAWnC,CAAC;AAEL,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AAEF,QAAA,MAAM,6BAA6B;;;kBAY/B,CAAC;AAEL,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,QAAA,MAAM,uBAAuB;;;kBAWzB,CAAC;AAEL,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,QAAA,MAAM,yBAAyB;;;kBAY3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,yBAAyB;;;;kBAe3B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,QAAA,MAAM,4BAA4B;;;;kBAe9B,CAAC;AAEL,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAgBxB,CAAC;AAEL,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,oBAAoB;;;;;CAMvB,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBA,CAAC;AAE9B,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}