@carrot-foundation/schemas 0.1.31 → 0.1.33

package/dist/index.cjs

@@ -32,7 +32,7 @@ var IsoTimestampSchema = zod.z.iso.datetime({
   description: "ISO 8601 formatted timestamp with timezone information",
   examples: ["2024-12-05T11:02:47.000Z", "2025-02-22T10:35:12.000Z"]
 });
-zod.z.iso.date("Must be a valid ISO 8601 date (YYYY-MM-DD)").meta({
+var IsoDateSchema = zod.z.iso.date("Must be a valid ISO 8601 date (YYYY-MM-DD)").meta({
   title: "ISO Date",
   description: "ISO 8601 formatted date in YYYY-MM-DD format",
   examples: ["2024-12-05", "2025-02-22", "2024-02-10"]
@@ -75,7 +75,7 @@ var NonEmptyStringSchema = zod.z.string().min(1, "Cannot be empty").meta({
   description: "A string that contains at least one character",
   examples: ["Example text", "Sample value", "Test string"]
 });
-NonEmptyStringSchema.regex(
+var SlugSchema = NonEmptyStringSchema.regex(
   /^[a-z0-9-]+$/,
   "Must contain only lowercase letters, numbers, and hyphens"
 ).max(100).meta({
@@ -122,17 +122,17 @@ var BlockchainChainIdSchema = zod.z.number().int().min(1).meta({
   description: "Blockchain network identifier",
   examples: [1, 137, 11155111]
 });
-zod.z.number().min(0).max(100).meta({
+var PercentageSchema = zod.z.number().min(0).max(100).meta({
   title: "Percentage",
   description: "Percentage value between 0 and 100",
   examples: [50, 75.5, 100]
 });
-zod.z.number().int().min(0).meta({
+var NonNegativeIntegerSchema = zod.z.number().int().min(0).meta({
   title: "Non-Negative Integer",
   description: "Integer value that is zero or positive",
   examples: [0, 123, 4126]
 });
-zod.z.number().int().min(1).meta({
+var PositiveIntegerSchema = zod.z.number().int().min(1).meta({
   title: "Positive Integer",
   description: "Integer value that is greater than zero",
   examples: [1, 123, 456]
@@ -236,7 +236,7 @@ var RecordSchemaTypeSchema = zod.z.enum([
   description: "Type of schema in the Carrot ecosystem",
   examples: ["MassID", "RecycledID", "GasID"]
 });
-NonEmptyStringSchema.max(10).regex(
+var TokenSymbolSchema = NonEmptyStringSchema.max(10).regex(
   /^[A-Z0-9-]+$/,
   "Must contain only uppercase letters, numbers, and hyphens"
 ).meta({
@@ -1150,7 +1150,7 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.31";
+  return "0.1.33";
 }
 
 // src/mass-id/mass-id.schema.ts
@@ -1170,10 +1170,536 @@ var MassIDIpfsSchema = NftIpfsSchema.safeExtend({
   attributes: MassIDAttributesSchema,
   data: MassIDDataSchema
 }).meta(MassIDIpfsSchemaMeta);
+var GasIDAttributeMethodologySchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Methodology"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Methodology Value",
+    description: "Name of the carbon methodology used for certification",
+    examples: ["BOLD Carbon (CH\u2084)"]
+  })
+}).meta({
+  title: "Methodology Attribute",
+  description: "Methodology attribute"
+});
+var GasIDAttributeGasTypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Gas Type"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Gas Type Value",
+    description: "Type of gas prevented",
+    examples: ["Methane (CH\u2084)", "Carbon Dioxide (CO\u2082)"]
+  })
+}).meta({
+  title: "Gas Type Attribute",
+  description: "Gas type attribute"
+});
+var GasIDAttributeCo2ePreventedSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("CO\u2082e Prevented (kg)"),
+  value: NonNegativeFloatSchema.meta({
+    title: "CO\u2082e Prevented Value",
+    description: "Total CO\u2082 equivalent emissions prevented in kilograms"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "CO\u2082e Prevented Attribute",
+  description: "CO\u2082e prevented attribute with numeric display"
+});
+var GasIDAttributeCreditAmountSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Credit Amount"),
+  value: NonNegativeFloatSchema.meta({
+    title: "Credit Amount Value",
+    description: "Amount of credits issued"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Credit Amount Attribute",
+  description: "Credit amount attribute with numeric display"
+});
+var GasIDAttributeCreditTypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Credit Type"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Credit Type Value",
+    description: "Type of credit issued",
+    examples: ["Carrot Carbon"]
+  })
+}).meta({
+  title: "Credit Type Attribute",
+  description: "Credit type attribute"
+});
+var GasIDAttributeSourceWasteTypeSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Source Waste Type"),
+  value: WasteTypeSchema
+}).meta({
+  title: "Source Waste Type Attribute",
+  description: "Source waste type attribute"
+});
+var GasIDAttributeSourceWeightSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Source Weight (kg)"),
+  value: WeightKgSchema,
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Source Weight Attribute",
+  description: "Source weight attribute with numeric display"
+});
+var GasIDAttributeOriginCountrySchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Origin Country"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Origin Country Value",
+    description: "Country where the waste was generated",
+    examples: ["Brazil"]
+  })
+}).meta({
+  title: "Origin Country Attribute",
+  description: "Origin country attribute"
+});
+var GasIDAttributeOriginMunicipalitySchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Origin Municipality"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Origin Municipality Value",
+    description: "Municipality where the waste was generated",
+    examples: ["Macap\xE1"]
+  })
+}).meta({
+  title: "Origin Municipality Attribute",
+  description: "Origin municipality attribute"
+});
+var GasIDAttributeRecyclerSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("Recycler"),
+  value: NonEmptyStringSchema.max(100).meta({
+    title: "Recycler Value",
+    description: "Organization that processed the waste",
+    examples: ["Eco Reciclagem"]
+  })
+}).meta({
+  title: "Recycler Attribute",
+  description: "Recycler attribute"
+});
+var GasIDAttributeMassIDTokenIdSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("MassID"),
+  value: NonEmptyStringSchema.regex(
+    /^#\d+$/,
+    "Must match pattern #<token_id>"
+  ).meta({
+    title: "MassID Token ID Value",
+    description: "Token ID of the source MassID NFT",
+    examples: ["#123"]
+  })
+}).meta({
+  title: "MassID Token ID Attribute",
+  description: "MassID token ID attribute"
+});
+var GasIDAttributeMassIDRecyclingDateSchema = NftAttributeSchema.extend({
+  trait_type: zod.z.literal("MassID Recycling Date"),
+  value: IsoDateSchema.meta({
+    title: "MassID Recycling Date Value",
+    description: "Date when the source waste was recycled",
+    examples: ["2025-02-22"]
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "MassID Recycling Date Attribute",
+  description: "MassID recycling date attribute with date display"
+});
+var GasIDAttributesSchema = zod.z.tuple([
+  GasIDAttributeMethodologySchema,
+  GasIDAttributeGasTypeSchema,
+  GasIDAttributeCo2ePreventedSchema,
+  GasIDAttributeCreditAmountSchema,
+  GasIDAttributeCreditTypeSchema,
+  GasIDAttributeSourceWasteTypeSchema,
+  GasIDAttributeSourceWeightSchema,
+  GasIDAttributeOriginCountrySchema,
+  GasIDAttributeOriginMunicipalitySchema,
+  GasIDAttributeRecyclerSchema,
+  GasIDAttributeMassIDTokenIdSchema,
+  GasIDAttributeMassIDRecyclingDateSchema
+]).meta({
+  title: "GasID NFT Attribute Array",
+  description: "Schema for the fixed set of GasID NFT attributes, enforcing order and type for each trait"
+});
+var WasteClassificationSchema = zod.z.strictObject({
+  primary_type: WasteTypeSchema.meta({
+    title: "Source Waste Primary Type",
+    description: "Primary type of the source waste"
+  }),
+  subtype: WasteSubtypeSchema.meta({
+    title: "Source Waste Subtype",
+    description: "Subtype of the source waste"
+  }),
+  net_weight_kg: WeightKgSchema.meta({
+    title: "Source Waste Net Weight",
+    description: "Net weight of the source waste"
+  })
+}).meta({
+  title: "Waste Classification",
+  description: "Classification of the source waste (MassID)"
+});
+var AccreditedParticipantSchema = zod.z.strictObject({
+  participant_id: UuidSchema.meta({
+    title: "Participant ID",
+    description: "Unique identifier for the participant"
+  }),
+  name: ParticipantNameSchema.meta({
+    title: "Participant Name",
+    description: "Name of the participant"
+  }),
+  role: ParticipantRoleSchema.meta({
+    title: "Participant Role",
+    description: "Role of the participant in the supply chain"
+  }),
+  accreditation_id: UuidSchema.meta({
+    title: "Accreditation ID",
+    description: "Unique identifier for the participant accreditation"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Participant Accreditation External URL",
+    description: "URL to view the participant accreditation on Carrot Explorer"
+  })
+}).meta({
+  title: "Accredited Participant",
+  description: "Participant with valid accreditation in the supply chain"
+});
+var AccreditedParticipantsSchema = zod.z.array(AccreditedParticipantSchema).min(1).meta({
+  title: "Accredited Participants",
+  description: "List of participants with valid accreditations"
+});
+var RewardAllocationSchema = zod.z.strictObject({
+  participant_id: UuidSchema.meta({
+    title: "Participant ID",
+    description: "Unique identifier for the participant receiving the reward"
+  }),
+  participant_name: ParticipantNameSchema.meta({
+    title: "Participant Name",
+    description: "Name of the participant receiving the reward"
+  }),
+  role: ParticipantRoleSchema.meta({
+    title: "Participant Role",
+    description: "Role of the participant in the supply chain"
+  }),
+  reward_percentage: PercentageSchema.meta({
+    title: "Reward Percentage",
+    description: "Reward percentage allocated to the participant"
+  }),
+  large_business_discount_applied: zod.z.boolean().optional().meta({
+    title: "Large Business Discount Applied",
+    description: "Whether the large business discount was applied"
+  }),
+  effective_percentage: PercentageSchema.meta({
+    title: "Effective Percentage",
+    description: "Effective percentage of the reward after discounts"
+  })
+}).meta({
+  title: "Reward Allocation",
+  description: "Reward allocation for a specific participant"
+});
+var DistributionNotesSchema = zod.z.strictObject({
+  large_business_discount_applied: NonEmptyStringSchema.optional().meta({
+    title: "Large Business Discount Applied",
+    description: "Description of the large business discount applied",
+    examples: [
+      "50% reduction applied to participants with >$4M annual revenue"
+    ]
+  }),
+  redirected_rewards: NonEmptyStringSchema.optional().meta({
+    title: "Redirected Rewards",
+    description: "Description of the redirected rewards",
+    examples: [
+      "Discounted rewards from large businesses redirected to accredited NGOs"
+    ]
+  })
+}).meta({
+  title: "Distribution Notes",
+  description: "Additional notes about the reward distribution"
+});
+var ParticipantRewardsSchema = zod.z.strictObject({
+  distribution_basis: NonEmptyStringSchema.max(200).meta({
+    title: "Distribution Basis",
+    description: "Basis for the rewards distribution"
+  }),
+  reward_allocations: zod.z.array(RewardAllocationSchema).min(1).meta({
+    title: "Reward Allocations",
+    description: "Rewards percentage allocated to each participant"
+  }),
+  distribution_notes: DistributionNotesSchema.optional().meta({
+    title: "Distribution Notes",
+    description: "Additional notes about the reward distribution"
+  })
+}).meta({
+  title: "Participant Rewards",
+  description: "Rewards distribution to participants"
+});
+var MethodologyComplianceSchema = zod.z.enum(["PASSED", "FAILED"]).meta({
+  title: "Methodology Compliance",
+  description: "Result of methodology compliance check",
+  examples: ["PASSED", "FAILED"]
+});
+var AuditReferenceSchema = zod.z.strictObject({
+  date: IsoDateSchema.meta({
+    title: "Audit Date",
+    description: "Date when the audit was completed"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Audit External ID",
+    description: "Unique identifier for the audit"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Audit External URL",
+    description: "URL to view the audit on Carrot Explorer"
+  }),
+  methodology_compliance: MethodologyComplianceSchema.meta({
+    title: "Methodology Compliance",
+    description: "Result of methodology compliance check"
+  }),
+  rules_executed: NonNegativeIntegerSchema.meta({
+    title: "Rules Executed",
+    description: "Number of rules executed during the audit"
+  }),
+  report: IpfsUriSchema.meta({
+    title: "Audit Report",
+    description: "IPFS URI of the audit report"
+  })
+}).meta({
+  title: "Audit Reference",
+  description: "Reference to an audit record"
+});
+var GasIDReferenceSchema = zod.z.strictObject({
+  external_id: ExternalIdSchema.meta({
+    title: "GasID External ID",
+    description: "Unique identifier for the GasID"
+  }),
+  token_id: TokenIdSchema.meta({
+    title: "GasID Token ID",
+    description: "NFT token ID of the GasID"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "GasID External URL",
+    description: "URL to view the GasID on Carrot Explorer"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "GasID IPFS URI",
+    description: "IPFS URI of the GasID record"
+  })
+}).meta({
+  title: "GasID Reference",
+  description: "Reference to a GasID record"
+});
+var MassIDReferenceSchema = zod.z.strictObject({
+  external_id: ExternalIdSchema.meta({
+    title: "MassID External ID",
+    description: "Unique identifier for the MassID"
+  }),
+  token_id: TokenIdSchema.meta({
+    title: "MassID Token ID",
+    description: "NFT token ID of the MassID"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "MassID External URL",
+    description: "URL to view the MassID on Carrot Explorer"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "MassID IPFS URI",
+    description: "IPFS URI of the MassID record"
+  })
+}).meta({
+  title: "MassID Reference",
+  description: "Reference to a MassID record"
+});
+var MethodologyReferenceSchema = zod.z.strictObject({
+  external_id: ExternalIdSchema.meta({
+    title: "Methodology External ID",
+    description: "Unique identifier for the methodology"
+  }),
+  name: NonEmptyStringSchema.min(5).max(150).meta({
+    title: "Methodology Name",
+    description: "Human-readable name of the methodology",
+    examples: ["BOLD Carbon (CH\u2084)", "BOLD Recycling"]
+  }),
+  version: SemanticVersionSchema.meta({
+    title: "Methodology Version",
+    description: "Version of the methodology"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Methodology External URL",
+    description: "URL to view the methodology on Carrot Explorer"
+  }),
+  uri: IpfsUriSchema.optional().meta({
+    title: "Methodology IPFS URI",
+    description: "IPFS URI to the methodology record"
+  })
+}).meta({
+  title: "Methodology Reference",
+  description: "Reference to a methodology record"
+});
+
+// src/gas-id/gas-id.data.schema.ts
+var GasIDSummarySchema = zod.z.strictObject({
+  gas_type: NonEmptyStringSchema.meta({
+    title: "Gas Type",
+    description: "Type of gas prevented",
+    examples: ["Methane (CH\u2084)", "Carbon Dioxide (CO\u2082)"]
+  }),
+  credit_type: NonEmptyStringSchema.meta({
+    title: "Credit Type",
+    description: "Type of credit issued",
+    examples: ["Carrot Carbon (C-CARB)", "Carbon Credit"]
+  }),
+  credit_amount: NonNegativeFloatSchema.meta({
+    title: "Credit Amount",
+    description: "Amount of credits issued"
+  }),
+  prevented_co2e_kg: WeightKgSchema.meta({
+    title: "Prevented Emissions (CO\u2082e kg)",
+    description: "CO\u2082e weight of the prevented emissions"
+  })
+}).meta({
+  title: "GasID Summary",
+  description: "Summary information for the GasID certificate"
+});
+var CalculationValueSchema = zod.z.strictObject({
+  reference: NonEmptyStringSchema.max(3).meta({
+    title: "Calculation Reference",
+    description: "Reference symbol used in the calculation formula",
+    examples: ["E", "B", "W", "R"]
+  }),
+  value: NonNegativeFloatSchema.meta({
+    title: "Calculation Value",
+    description: "Numeric value for this calculation parameter"
+  }),
+  label: NonEmptyStringSchema.max(100).meta({
+    title: "Calculation Label",
+    description: "Human-readable label for this calculation value",
+    examples: [
+      "Exceeding Emission Coefficient",
+      "Prevented Emissions by Waste Subtype and Baseline Per Ton",
+      "Waste Weight",
+      "Prevented Emissions (CO\u2082e kg)"
+    ]
+  })
+}).meta({
+  title: "Calculation Value",
+  description: "Single value used in the emissions calculation"
+});
+var PreventedEmissionsCalculationSchema = zod.z.strictObject({
+  formula: NonEmptyStringSchema.max(100).meta({
+    title: "Calculation Formula",
+    description: "Formula used to calculate the prevented emissions",
+    examples: ["(1 - B) * W * E = R"]
+  }),
+  method: NonEmptyStringSchema.max(100).meta({
+    title: "Calculation Method",
+    description: "Method used to calculate the prevented emissions",
+    examples: ["UNFCCC AMS-III.F"]
+  }),
+  date: IsoDateSchema.meta({
+    title: "Calculation Date",
+    description: "Date when the calculation was performed"
+  }),
+  values: zod.z.array(CalculationValueSchema).min(1).meta({
+    title: "Calculation Values",
+    description: "Values used to calculate the prevented emissions"
+  })
+}).meta({
+  title: "Prevented Emissions Calculation",
+  description: "Details of the prevented emissions calculation"
+});
+var GasIDDataSchema = zod.z.strictObject({
+  summary: GasIDSummarySchema,
+  methodology: MethodologyReferenceSchema,
+  audit: AuditReferenceSchema,
+  mass_id: MassIDReferenceSchema,
+  waste_classification: WasteClassificationSchema,
+  origin_location: LocationSchema.meta({
+    title: "Source Waste Origin Location",
+    description: "Location of the waste origin"
+  }),
+  prevented_emissions_calculation: PreventedEmissionsCalculationSchema,
+  accredited_participants: AccreditedParticipantsSchema,
+  participant_rewards: ParticipantRewardsSchema.optional()
+}).meta({
+  title: "GasID Data",
+  description: "Complete data structure for GasID certificate"
+});
+var GasIDIpfsSchemaMeta = {
+  title: "GasID NFT IPFS Record",
+  description: "Complete GasID NFT IPFS record including fixed attributes and detailed carbon emissions prevention data",
+  $id: buildSchemaUrl("gas-id/gas-id.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var GasIDIpfsSchema = NftIpfsSchema.safeExtend({
+  schema: NftIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("GasID").meta({
+      title: "GasID Schema Type",
+      description: "GasID NFT schema type"
+    })
+  }),
+  attributes: GasIDAttributesSchema,
+  data: GasIDDataSchema
+}).meta(GasIDIpfsSchemaMeta);
 
+exports.AccreditedParticipantSchema = AccreditedParticipantSchema;
+exports.AccreditedParticipantsSchema = AccreditedParticipantsSchema;
+exports.AuditReferenceSchema = AuditReferenceSchema;
+exports.BaseIpfsSchema = BaseIpfsSchema;
+exports.BlockchainChainIdSchema = BlockchainChainIdSchema;
+exports.CoordinatesSchema = CoordinatesSchema;
+exports.DistributionNotesSchema = DistributionNotesSchema;
+exports.EthereumAddressSchema = EthereumAddressSchema;
+exports.ExternalIdSchema = ExternalIdSchema;
+exports.ExternalUrlSchema = ExternalUrlSchema;
+exports.FacilityTypeSchema = FacilityTypeSchema;
+exports.GasIDAttributesSchema = GasIDAttributesSchema;
+exports.GasIDDataSchema = GasIDDataSchema;
+exports.GasIDIpfsSchema = GasIDIpfsSchema;
+exports.GasIDIpfsSchemaMeta = GasIDIpfsSchemaMeta;
+exports.GasIDReferenceSchema = GasIDReferenceSchema;
+exports.HexColorSchema = HexColorSchema;
+exports.HoursSchema = HoursSchema;
+exports.IpfsUriSchema = IpfsUriSchema;
+exports.IsoAdministrativeDivisionCodeSchema = IsoAdministrativeDivisionCodeSchema;
+exports.IsoCountryCodeSchema = IsoCountryCodeSchema;
+exports.IsoDateSchema = IsoDateSchema;
+exports.IsoTimestampSchema = IsoTimestampSchema;
+exports.Keccak256HashSchema = Keccak256HashSchema;
+exports.LatitudeSchema = LatitudeSchema;
+exports.LocationSchema = LocationSchema;
+exports.LongitudeSchema = LongitudeSchema;
 exports.MassIDAttributesSchema = MassIDAttributesSchema;
 exports.MassIDDataSchema = MassIDDataSchema;
 exports.MassIDIpfsSchema = MassIDIpfsSchema;
 exports.MassIDIpfsSchemaMeta = MassIDIpfsSchemaMeta;
+exports.MassIDReferenceSchema = MassIDReferenceSchema;
+exports.MethodologyComplianceSchema = MethodologyComplianceSchema;
+exports.MethodologyReferenceSchema = MethodologyReferenceSchema;
+exports.MinutesSchema = MinutesSchema;
+exports.NftAttributeSchema = NftAttributeSchema;
+exports.NftIpfsSchema = NftIpfsSchema;
+exports.NonEmptyStringSchema = NonEmptyStringSchema;
+exports.NonNegativeFloatSchema = NonNegativeFloatSchema;
+exports.NonNegativeIntegerSchema = NonNegativeIntegerSchema;
+exports.ParticipantNameSchema = ParticipantNameSchema;
+exports.ParticipantRewardsSchema = ParticipantRewardsSchema;
+exports.ParticipantRoleSchema = ParticipantRoleSchema;
+exports.ParticipantSchema = ParticipantSchema;
+exports.PercentageSchema = PercentageSchema;
+exports.PositiveIntegerSchema = PositiveIntegerSchema;
+exports.RecordEnvironmentSchema = RecordEnvironmentSchema;
+exports.RecordRelationshipTypeSchema = RecordRelationshipTypeSchema;
+exports.RecordSchemaTypeSchema = RecordSchemaTypeSchema;
+exports.RewardAllocationSchema = RewardAllocationSchema;
+exports.SemanticVersionSchema = SemanticVersionSchema;
+exports.Sha256HashSchema = Sha256HashSchema;
+exports.SlugSchema = SlugSchema;
+exports.TokenIdSchema = TokenIdSchema;
+exports.TokenSymbolSchema = TokenSymbolSchema;
+exports.UnixTimestampSchema = UnixTimestampSchema;
+exports.UuidSchema = UuidSchema;
+exports.WasteClassificationSchema = WasteClassificationSchema;
+exports.WasteSubtypeSchema = WasteSubtypeSchema;
+exports.WasteTypeSchema = WasteTypeSchema;
+exports.WeightKgSchema = WeightKgSchema;
+exports.buildSchemaUrl = buildSchemaUrl;
+exports.getSchemaBaseUrl = getSchemaBaseUrl;
+exports.getSchemaVersionOrDefault = getSchemaVersionOrDefault;
+exports.uniqueArrayItems = uniqueArrayItems;
+exports.uniqueBy = uniqueBy;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map