@carrot-foundation/schemas 0.1.36 → 0.1.37

package/dist/index.cjs

@@ -15,7 +15,7 @@ var UuidSchema = zod.z.uuidv4("Must be a valid UUID v4 string").meta({
   ]
 });
 var EthereumAddressSchema = zod.z.string().regex(
-  /^0x[a-fA-F0-9]{40}$/,
+  /^0x[a-f0-9]{40}$/,
   "Must be a valid Ethereum address in lowercase hexadecimal format"
 ).meta({
   title: "Ethereum Address",
@@ -90,6 +90,11 @@ var CountryNameSchema = NonEmptyStringSchema.max(50).meta({
   description: "Full country name in English",
   examples: ["Brazil", "United States", "Germany", "Japan"]
 });
+var CollectionNameSchema = NonEmptyStringSchema.max(150).meta({
+  title: "Collection Name",
+  description: "Display name of the collection",
+  examples: ["BOLD Cold Start - Carazinho", "BOLD Brazil"]
+});
 var MethodologyNameSchema = NonEmptyStringSchema.max(100).meta({
   title: "Methodology Name",
   description: "Name of the methodology used for certification",
@@ -111,6 +116,11 @@ var SlugSchema = NonEmptyStringSchema.regex(
   description: "URL-friendly identifier with lowercase letters, numbers, and hyphens",
   examples: ["mass-id-123", "recycled-plastic", "organic-waste"]
 });
+var CollectionSlugSchema = SlugSchema.meta({
+  title: "Collection Slug",
+  description: "URL-friendly identifier for a collection",
+  examples: ["bold-cold-start-carazinho", "bold-brazil"]
+});
 var WasteTypeSchema = NonEmptyStringSchema.max(100).meta({
   title: "Waste Type",
   description: "Category or type of waste material",
@@ -150,6 +160,23 @@ var BlockchainChainIdSchema = zod.z.number().int().min(1).meta({
   description: "Blockchain network identifier",
   examples: [1, 137, 11155111]
 });
+var BlockchainNetworkNameSchema = NonEmptyStringSchema.max(100).meta({
+  title: "Blockchain Network Name",
+  description: "Name of the blockchain network",
+  examples: ["Polygon", "Ethereum mainnet", "Sepolia"]
+});
+var SmartContractAddressSchema = EthereumAddressSchema.meta({
+  title: "Smart Contract Address",
+  description: "Address of the smart contract"
+});
+var SmartContractSchema = zod.z.strictObject({
+  address: SmartContractAddressSchema,
+  chain_id: BlockchainChainIdSchema,
+  network_name: BlockchainNetworkNameSchema
+}).meta({
+  title: "Smart Contract",
+  description: "Smart contract details for on-chain references"
+});
 var PercentageSchema = zod.z.number().min(0).max(100).meta({
   title: "Percentage",
   description: "Percentage value between 0 and 100",
@@ -264,7 +291,7 @@ var RecordSchemaTypeSchema = zod.z.enum([
   "MassID Audit",
   "RecycledID",
   "GasID",
-  "PurchaseID",
+  "CreditPurchaseReceipt",
   "Methodology",
   "Credit",
   "Collection"
@@ -288,12 +315,12 @@ var RecordRelationshipTypeSchema = zod.z.enum([
   "mass-id",
   "mass-id-audit",
   "methodology",
-  "purchase-id",
+  "credit-purchase-receipt",
   "recycled-id"
 ]).meta({
   title: "Relationship Type",
   description: "Type of relationship between different entities in the system",
-  examples: ["mass-id", "audit", "collection"]
+  examples: ["mass-id", "collection", "credit-purchase-receipt"]
 });
 function uniqueArrayItems(schema, errorMessage = "Array items must be unique") {
   return zod.z.array(schema).refine((items) => new Set(items).size === items.length, {
@@ -706,7 +733,7 @@ var NftSchemaTypeSchema = RecordSchemaTypeSchema.extract([
   "MassID",
   "RecycledID",
   "GasID",
-  "PurchaseID"
+  "CreditPurchaseReceipt"
 ]).meta({
   title: "NFT Schema Type",
   description: "Type of schema for NFT records"
@@ -883,16 +910,16 @@ function buildSchemaUrl(schemaPath) {
   return `${getSchemaBaseUrl()}/${cleanPath}`;
 }
 function getSchemaVersionOrDefault() {
-  return "0.1.36";
+  return "0.1.37";
 }
-var MethodologyAttributeSchema = NftAttributeSchema.extend({
+var MethodologyAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Methodology"),
   value: MethodologyNameSchema
 }).meta({
   title: "Methodology Attribute",
   description: "Methodology used for certification"
 });
-var CreditAmountAttributeSchema = NftAttributeSchema.extend({
+var CreditAmountAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Credit Amount"),
   value: CreditAmountSchema,
   display_type: zod.z.literal("number")
@@ -900,21 +927,21 @@ var CreditAmountAttributeSchema = NftAttributeSchema.extend({
   title: "Credit Amount Attribute",
   description: "Credit amount attribute with numeric display"
 });
-var CreditTypeAttributeSchema = NftAttributeSchema.extend({
+var CreditTypeAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Credit Type"),
   value: CreditTypeSchema
 }).meta({
   title: "Credit Type Attribute",
   description: "Credit type attribute"
 });
-var SourceWasteTypeAttributeSchema = NftAttributeSchema.extend({
+var SourceWasteTypeAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Source Waste Type"),
   value: WasteTypeSchema
 }).meta({
   title: "Source Waste Type Attribute",
   description: "Source waste type attribute"
 });
-var SourceWeightAttributeSchema = NftAttributeSchema.extend({
+var SourceWeightAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Source Weight (kg)"),
   value: WeightKgSchema.meta({
     title: "Source Weight",
@@ -925,21 +952,21 @@ var SourceWeightAttributeSchema = NftAttributeSchema.extend({
   title: "Source Weight Attribute",
   description: "Source weight attribute with numeric display"
 });
-var OriginCountryAttributeSchema = NftAttributeSchema.extend({
+var OriginCountryAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Origin Country"),
   value: CountryNameSchema
 }).meta({
   title: "Origin Country Attribute",
   description: "Origin country attribute"
 });
-var OriginMunicipalityAttributeSchema = NftAttributeSchema.extend({
+var OriginMunicipalityAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Origin Municipality"),
   value: MunicipalitySchema
 }).meta({
   title: "Origin Municipality Attribute",
   description: "Origin municipality attribute"
 });
-var RecyclerAttributeSchema = NftAttributeSchema.extend({
+var RecyclerAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycler"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycler",
@@ -950,7 +977,7 @@ var RecyclerAttributeSchema = NftAttributeSchema.extend({
   title: "Recycler Attribute",
   description: "Recycler attribute"
 });
-var MassIDTokenIdAttributeSchema = NftAttributeSchema.extend({
+var MassIDTokenIdAttributeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("MassID"),
   value: StringifiedTokenIdSchema.meta({
     title: "MassID Token ID",
@@ -962,7 +989,7 @@ var MassIDTokenIdAttributeSchema = NftAttributeSchema.extend({
 });
 var MassIDRecyclingDateAttributeSchema = NftAttributeSchema.omit({
   max_value: true
-}).extend({
+}).safeExtend({
   trait_type: zod.z.literal("MassID Recycling Date"),
   value: UnixTimestampSchema.meta({
     title: "MassID Recycling Date",
@@ -973,23 +1000,108 @@ var MassIDRecyclingDateAttributeSchema = NftAttributeSchema.omit({
   title: "MassID Recycling Date Attribute",
   description: "MassID recycling date attribute using Unix timestamp in milliseconds"
 });
+var AuditRuleDefinitionSchema = zod.z.strictObject({
+  rule_id: UuidSchema.meta({
+    title: "Rule ID",
+    description: "Unique identifier for the audit rule"
+  }),
+  rule_slug: SlugSchema.meta({
+    title: "Rule Slug",
+    description: "URL-friendly identifier for the rule"
+  }),
+  rule_name: NonEmptyStringSchema.max(100).meta({
+    title: "Rule Name",
+    description: "Human-readable name of the rule",
+    examples: ["Waste Mass is Unique", "No Conflicting GasID or Credit"]
+  }),
+  description: zod.z.string().min(10).max(500).meta({
+    title: "Rule Description",
+    description: "Detailed description of what the rule validates and why it is necessary",
+    examples: [
+      "Validates that each MassID is unique within the system to prevent duplicate entries"
+    ]
+  }),
+  source_code_url: zod.z.url().regex(/^https:\/\/github\.com\/.*$/, "Must be a GitHub URL").meta({
+    title: "Rule Source Code URL",
+    description: "GitHub URL pointing to the implementation source code for this rule",
+    examples: [
+      "https://github.com/carrot-foundation/methodologies/blob/main/bold-carbon/rules/waste-mass-unique.js"
+    ]
+  }),
+  mandatory: zod.z.boolean().meta({
+    title: "Mandatory",
+    description: "Whether this rule is mandatory for methodology compliance"
+  }),
+  execution_order: PositiveIntegerSchema.meta({
+    title: "Rule Execution Order",
+    description: "Sequential order in which this rule must be executed"
+  })
+}).meta({
+  title: "Audit Rule Definition",
+  description: "Definition of an audit rule that must be executed for methodology compliance"
+});
+var AuditRuleDefinitionsSchema = zod.z.array(AuditRuleDefinitionSchema).min(1).meta({
+  title: "Audit Rule Definitions",
+  description: "List of audit rules that must be executed to check methodology compliance"
+});
+var AuditRuleExecutionResultSchema = zod.z.strictObject({
+  rule_name: NonEmptyStringSchema.meta({
+    title: "Rule Name",
+    description: "Human-readable name of the audit rule"
+  }),
+  rule_id: UuidSchema.meta({
+    title: "Rule ID",
+    description: "Unique identifier for the rule"
+  }),
+  rule_slug: SlugSchema.meta({
+    title: "Rule Slug",
+    description: "URL-friendly identifier for the rule"
+  }),
+  execution_order: PositiveIntegerSchema.meta({
+    title: "Rule Execution Order",
+    description: "Sequential order in which this rule was executed"
+  }),
+  result: MethodologyComplianceSchema.meta({
+    title: "Rule Execution Result",
+    description: "Result of the rule execution"
+  }),
+  description: zod.z.string().min(1).max(2e3).meta({
+    title: "Rule Description",
+    description: "Detailed description of what this rule validates"
+  }),
+  rule_processor_checksum: NonEmptyStringSchema.max(200).meta({
+    title: "Rule Processor Checksum",
+    description: "Checksum for rule processor integrity verification"
+  }),
+  rule_source_code_version: NonEmptyStringSchema.max(200).meta({
+    title: "Rule Source Code Version",
+    description: "Version identifier for the rule source code"
+  })
+}).meta({
+  title: "Audit Rule Execution Result",
+  description: "Detailed result of an audit rule execution"
+});
+var AuditRuleExecutionResultsSchema = zod.z.array(AuditRuleExecutionResultSchema).meta({
+  title: "Audit Rule Execution Results",
+  description: "Detailed results of each audit rule execution"
+});
 
 // src/mass-id/mass-id.attributes.ts
-var MassIDAttributeWasteTypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeWasteTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Waste Type"),
   value: WasteTypeSchema
 }).meta({
   title: "Waste Type Attribute",
   description: "Waste type attribute"
 });
-var MassIDAttributeWasteSubtypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeWasteSubtypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Waste Subtype"),
   value: WasteSubtypeSchema
 }).meta({
   title: "Waste Subtype Attribute",
   description: "Waste subtype attribute"
 });
-var MassIDAttributeWeightSchema = NftAttributeSchema.extend({
+var MassIDAttributeWeightSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weight (kg)"),
   value: WeightKgSchema,
   display_type: zod.z.literal("number")
@@ -997,20 +1109,20 @@ var MassIDAttributeWeightSchema = NftAttributeSchema.extend({
   title: "Weight Attribute",
   description: "Weight attribute with numeric display"
 });
-var MassIDAttributeOriginCountrySchema = OriginCountryAttributeSchema.extend({
+var MassIDAttributeOriginCountrySchema = OriginCountryAttributeSchema.safeExtend({
   value: CountryNameSchema
 });
-var MassIDAttributeOriginMunicipalitySchema = OriginMunicipalityAttributeSchema.extend({
+var MassIDAttributeOriginMunicipalitySchema = OriginMunicipalityAttributeSchema.safeExtend({
   value: MunicipalitySchema
 });
-var MassIDAttributeOriginDivisionSchema = NftAttributeSchema.extend({
+var MassIDAttributeOriginDivisionSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Origin Administrative Division"),
   value: AdministrativeDivisionSchema
 }).meta({
   title: "Origin Administrative Division Attribute",
   description: "Origin administrative division attribute"
 });
-var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Vehicle Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Vehicle Type",
@@ -1021,7 +1133,7 @@ var MassIDAttributeVehicleTypeSchema = NftAttributeSchema.extend({
   title: "Vehicle Type Attribute",
   description: "Vehicle type attribute"
 });
-var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.extend({
+var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycling Method",
@@ -1036,7 +1148,7 @@ var MassIDAttributeRecyclingMethodSchema = NftAttributeSchema.extend({
   title: "Recycling Method Attribute",
   description: "Recycling method attribute"
 });
-var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.extend({
+var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Processing Time (hours)"),
   value: HoursSchema,
   trait_description: NonEmptyStringSchema.max(200).optional().meta({
@@ -1047,7 +1159,7 @@ var MassIDAttributeProcessingTimeSchema = NftAttributeSchema.extend({
   title: "Processing Time Attribute",
   description: "Processing time attribute with optional trait description"
 });
-var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.extend({
+var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Local Waste Classification ID"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Local Waste Classification ID",
@@ -1058,7 +1170,7 @@ var MassIDAttributeLocalWasteClassificationIdSchema = NftAttributeSchema.extend(
   title: "Local Waste Classification ID Attribute",
   description: "Local waste classification ID attribute"
 });
-var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.extend({
+var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Manifest Code"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Recycling Manifest Code",
@@ -1069,7 +1181,7 @@ var MassIDAttributeRecyclingManifestCodeSchema = NftAttributeSchema.extend({
   title: "Recycling Manifest Code Attribute",
   description: "Recycling manifest code attribute (optional)"
 });
-var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.extend({
+var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Transport Manifest Code"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Transport Manifest Code",
@@ -1080,7 +1192,7 @@ var MassIDAttributeTransportManifestCodeSchema = NftAttributeSchema.extend({
   title: "Transport Manifest Code Attribute",
   description: "Transport manifest code attribute (optional)"
 });
-var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.extend({
+var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Weighing Capture Method"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Weighing Capture Method",
@@ -1091,7 +1203,7 @@ var MassIDAttributeWeighingCaptureMethodSchema = NftAttributeSchema.extend({
   title: "Weighing Capture Method Attribute",
   description: "Weighing capture method attribute (optional)"
 });
-var MassIDAttributeScaleTypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeScaleTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Scale Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Scale Type",
@@ -1107,7 +1219,7 @@ var MassIDAttributeScaleTypeSchema = NftAttributeSchema.extend({
   title: "Scale Type Attribute",
   description: "Scale type attribute (optional)"
 });
-var MassIDAttributeContainerTypeSchema = NftAttributeSchema.extend({
+var MassIDAttributeContainerTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Container Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Container Type",
@@ -1118,7 +1230,7 @@ var MassIDAttributeContainerTypeSchema = NftAttributeSchema.extend({
   title: "Container Type Attribute",
   description: "Container type attribute (optional)"
 });
-var MassIDAttributePickUpDateSchema = NftAttributeSchema.extend({
+var MassIDAttributePickUpDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Pick-up Date"),
   value: UnixTimestampSchema.meta({
     title: "Pick-up Date",
@@ -1130,7 +1242,7 @@ var MassIDAttributePickUpDateSchema = NftAttributeSchema.extend({
   title: "Pick-up Date Attribute",
   description: "Pick-up date attribute with Unix timestamp"
 });
-var MassIDAttributeRecyclingDateSchema = NftAttributeSchema.extend({
+var MassIDAttributeRecyclingDateSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycling Date"),
   value: UnixTimestampSchema.meta({
     title: "Recycling Date",
@@ -1469,7 +1581,7 @@ var MassIDIpfsSchema = NftIpfsSchema.safeExtend({
   data: MassIDDataSchema
 }).meta(MassIDIpfsSchemaMeta);
 var GasIDAttributeMethodologySchema = MethodologyAttributeSchema;
-var GasIDAttributeGasTypeSchema = NftAttributeSchema.extend({
+var GasIDAttributeGasTypeSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Gas Type"),
   value: NonEmptyStringSchema.max(100).meta({
     title: "Gas Type",
@@ -1480,7 +1592,7 @@ var GasIDAttributeGasTypeSchema = NftAttributeSchema.extend({
   title: "Gas Type Attribute",
   description: "Gas type attribute"
 });
-var GasIDAttributeCo2ePreventedSchema = NftAttributeSchema.extend({
+var GasIDAttributeCo2ePreventedSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("CO\u2082e Prevented (kg)"),
   value: NonNegativeFloatSchema.meta({
     title: "CO\u2082e Prevented",
@@ -1614,7 +1726,7 @@ var GasIDIpfsSchema = NftIpfsSchema.safeExtend({
   data: GasIDDataSchema
 }).meta(GasIDIpfsSchemaMeta);
 var RecycledIDAttributeMethodologySchema = MethodologyAttributeSchema;
-var RecycledIDAttributeRecycledMassWeightSchema = NftAttributeSchema.extend({
+var RecycledIDAttributeRecycledMassWeightSchema = NftAttributeSchema.safeExtend({
   trait_type: zod.z.literal("Recycled Mass Weight (kg)"),
   value: WeightKgSchema.meta({
     title: "Recycled Mass Weight",
@@ -1693,17 +1805,985 @@ var RecycledIDIpfsSchema = NftIpfsSchema.safeExtend({
   attributes: RecycledIDAttributesSchema,
   data: RecycledIDDataSchema
 }).meta(RecycledIDIpfsSchemaMeta);
+var CreditPurchaseReceiptCreditAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: TokenSymbolSchema.meta({
+    title: "Credit Token Symbol",
+    description: "Symbol of the credit token (e.g., C-CARB, C-BIOW)",
+    examples: ["C-CARB", "C-BIOW"]
+  }),
+  value: CreditAmountSchema.meta({
+    title: "Credit Amount",
+    description: "Amount of credits purchased for the token symbol"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Credit Attribute",
+  description: "Attribute representing purchased amount per credit token symbol"
+});
+var CreditPurchaseReceiptTotalCreditsAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Total Credits Purchased"),
+  value: CreditAmountSchema.meta({
+    title: "Total Credits Purchased",
+    description: "Total number of credits purchased across all tokens"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Total Credits Purchased Attribute",
+  description: "Aggregate credits purchased attribute"
+});
+var CreditPurchaseReceiptTotalUsdcAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Total USDC Amount"),
+  value: CreditAmountSchema.meta({
+    title: "Total USDC Amount",
+    description: "Total USDC amount paid for the purchase"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Total USDC Amount Attribute",
+  description: "Aggregate USDC amount attribute"
+});
+var CreditPurchaseReceiptPurchaseDateAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Purchase Date"),
+  value: UnixTimestampSchema.meta({
+    title: "Purchase Date",
+    description: "Unix timestamp in milliseconds when the purchase was completed"
+  }),
+  display_type: zod.z.literal("date")
+}).meta({
+  title: "Purchase Date Attribute",
+  description: "Purchase date attribute using Unix timestamp in milliseconds"
+});
+var CreditPurchaseReceiptCertificatesAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: zod.z.literal("Certificates Purchased"),
+  value: PositiveIntegerSchema.meta({
+    title: "Certificates Purchased",
+    description: "Total number of certificates purchased"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Certificates Purchased Attribute",
+  description: "Attribute representing how many certificates were purchased"
+});
+var CreditPurchaseReceiptReceiverAttributeSchema = NftAttributeSchema.omit({
+  display_type: true,
+  max_value: true
+}).safeExtend({
+  trait_type: zod.z.literal("Receiver"),
+  value: ParticipantNameSchema.meta({
+    title: "Receiver",
+    description: "Organization or individual receiving the credits from the purchase",
+    examples: ["EcoTech Solutions Inc."]
+  })
+}).meta({
+  title: "Receiver Attribute",
+  description: "Attribute containing the receiver display name"
+});
+var CreditPurchaseReceiptCollectionAttributeSchema = NftAttributeSchema.safeExtend({
+  trait_type: CollectionNameSchema,
+  value: CreditAmountSchema.meta({
+    title: "Credits from Collection",
+    description: "Amount of credits purchased from the collection"
+  }),
+  display_type: zod.z.literal("number")
+}).meta({
+  title: "Collection Attribute",
+  description: "Attribute representing the amount of credits purchased from a collection"
+});
+var CreditPurchaseReceiptAttributesSchema = uniqueBy(
+  zod.z.union([
+    CreditPurchaseReceiptCreditAttributeSchema,
+    CreditPurchaseReceiptTotalCreditsAttributeSchema,
+    CreditPurchaseReceiptTotalUsdcAttributeSchema,
+    CreditPurchaseReceiptPurchaseDateAttributeSchema,
+    CreditPurchaseReceiptCertificatesAttributeSchema,
+    CreditPurchaseReceiptReceiverAttributeSchema,
+    CreditPurchaseReceiptCollectionAttributeSchema
+  ]),
+  (attribute) => attribute.trait_type,
+  "Attribute trait_type values must be unique"
+).min(5).meta({
+  title: "Credit Purchase Receipt NFT Attribute Array",
+  description: "Attributes for credit purchase receipts including per-credit breakdowns, totals, receiver, purchase date, and per-collection amounts. Attributes must have unique trait types."
+});
+var CreditPurchaseReceiptSummarySchema = zod.z.strictObject({
+  total_usdc_amount: NonNegativeFloatSchema.meta({
+    title: "Total USDC Amount",
+    description: "Total amount paid in USDC for the purchase"
+  }),
+  total_credits: CreditAmountSchema.meta({
+    title: "Total Credits",
+    description: "Total amount of credits purchased"
+  }),
+  total_certificates: PositiveIntegerSchema.meta({
+    title: "Total Certificates",
+    description: "Total number of certificates purchased"
+  }),
+  purchase_date: IsoDateSchema.meta({
+    title: "Purchase Date",
+    description: "Date when the purchase was made (YYYY-MM-DD)"
+  }),
+  credit_symbols: uniqueArrayItems(
+    TokenSymbolSchema,
+    "Credit symbols must be unique"
+  ).min(1).meta({
+    title: "Credit Symbols",
+    description: "Array of credit token symbols included in the purchase"
+  }),
+  certificate_types: uniqueArrayItems(
+    RecordSchemaTypeSchema.extract(["GasID", "RecycledID"]),
+    "Certificate types must be unique"
+  ).min(1).meta({
+    title: "Certificate Types",
+    description: "Array of certificate types included in the purchase"
+  }),
+  collection_slugs: uniqueArrayItems(
+    CollectionSlugSchema,
+    "Collection slugs must be unique"
+  ).min(1).meta({
+    title: "Collection Slugs",
+    description: "Array of collection slugs represented in the purchase"
+  })
+}).meta({
+  title: "Credit Purchase Receipt Summary",
+  description: "Summary totals for the credit purchase including amounts and collections represented"
+});
+var CreditPurchaseReceiptIdentitySchema = zod.z.strictObject({
+  name: ParticipantNameSchema.meta({
+    title: "Identity Name",
+    description: "Display name for the participant",
+    examples: ["EcoTech Solutions Inc."]
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Identity External ID",
+    description: "External identifier for the participant"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Identity External URL",
+    description: "External URL for the participant profile"
+  })
+}).meta({
+  title: "Identity",
+  description: "Participant identity information"
+});
+var CreditPurchaseReceiptReceiverSchema = zod.z.strictObject({
+  wallet_address: EthereumAddressSchema.meta({
+    title: "Receiver Wallet Address",
+    description: "Ethereum address of the receiver"
+  }),
+  identity: CreditPurchaseReceiptIdentitySchema.optional()
+}).meta({
+  title: "Receiver",
+  description: "Receiver wallet and optional identity information"
+});
+var CreditPurchaseReceiptBuyerSchema = zod.z.strictObject({
+  buyer_id: ExternalIdSchema.meta({
+    title: "Buyer ID",
+    description: "Unique identifier for the buyer"
+  }),
+  identity: CreditPurchaseReceiptIdentitySchema.optional()
+}).meta({
+  title: "Buyer",
+  description: "Buyer identifier and optional identity information"
+});
+var CreditPurchaseReceiptPartiesSchema = zod.z.strictObject({
+  payer: EthereumAddressSchema.meta({
+    title: "Payer Wallet Address",
+    description: "Ethereum address paying for the purchase"
+  }),
+  receiver: CreditPurchaseReceiptReceiverSchema,
+  buyer: CreditPurchaseReceiptBuyerSchema.optional()
+}).meta({
+  title: "Parties",
+  description: "Parties involved in the purchase including payer, receiver, and optional buyer"
+});
+var CreditPurchaseReceiptCollectionSchema = zod.z.strictObject({
+  slug: CollectionSlugSchema,
+  external_id: ExternalIdSchema.meta({
+    title: "Collection External ID",
+    description: "External identifier for the collection"
+  }),
+  name: CollectionNameSchema,
+  external_url: ExternalUrlSchema.meta({
+    title: "Collection External URL",
+    description: "External URL for the collection"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "Collection URI",
+    description: "IPFS URI for the collection metadata"
+  }),
+  credit_amount: CreditAmountSchema.meta({
+    title: "Collection Credit Amount",
+    description: "Total credits purchased from this collection"
+  })
+}).meta({
+  title: "Collection",
+  description: "Collection included in the purchase"
+});
+var CreditPurchaseReceiptCreditSchema = zod.z.strictObject({
+  slug: SlugSchema.meta({
+    title: "Credit Slug",
+    description: "URL-friendly identifier for the credit"
+  }),
+  symbol: TokenSymbolSchema.meta({
+    title: "Credit Token Symbol",
+    description: "Symbol of the credit token",
+    examples: ["C-CARB", "C-BIOW"]
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Credit External ID",
+    description: "External identifier for the credit"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Credit External URL",
+    description: "External URL for the credit"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "Credit URI",
+    description: "IPFS URI for the credit details"
+  }),
+  smart_contract: SmartContractSchema,
+  purchase_amount: CreditAmountSchema.meta({
+    title: "Credit Purchase Amount",
+    description: "Total credits purchased for this credit type"
+  }),
+  retirement_amount: CreditAmountSchema.optional().meta({
+    title: "Credit Retirement Amount",
+    description: "Credits retired immediately for this credit type during purchase"
+  })
+}).meta({
+  title: "Credit",
+  description: "Credit token included in the purchase"
+});
+var MassIDReferenceWithContractSchema = MassIDReferenceSchema.omit({
+  external_id: true
+}).safeExtend({
+  external_id: ExternalIdSchema.meta({
+    title: "MassID External ID",
+    description: "Unique identifier for the referenced MassID"
+  }),
+  smart_contract: SmartContractSchema
+}).meta({
+  title: "MassID Reference with Smart Contract",
+  description: "Reference to a MassID record including smart contract details"
+});
+var CreditPurchaseReceiptCertificateSchema = zod.z.strictObject({
+  token_id: TokenIdSchema.meta({
+    title: "Certificate Token ID",
+    description: "Token ID of the certificate"
+  }),
+  type: RecordSchemaTypeSchema.extract(["GasID", "RecycledID"]).meta({
+    title: "Certificate Type",
+    description: "Type of certificate (e.g., GasID, RecycledID)"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Certificate External ID",
+    description: "External identifier for the certificate"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Certificate External URL",
+    description: "External URL for the certificate"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "Certificate URI",
+    description: "IPFS URI for the certificate metadata"
+  }),
+  smart_contract: SmartContractSchema,
+  collection_slug: CollectionSlugSchema.meta({
+    title: "Collection Slug",
+    description: "Slug of the collection this certificate belongs to"
+  }),
+  total_amount: CreditAmountSchema.meta({
+    title: "Certificate Total Amount",
+    description: "Total credits available in this certificate"
+  }),
+  purchased_amount: CreditAmountSchema.meta({
+    title: "Certificate Purchased Amount",
+    description: "Credits purchased from this certificate"
+  }),
+  retired_amount: CreditAmountSchema.meta({
+    title: "Certificate Retired Amount",
+    description: "Credits retired from this certificate during the purchase (0 if none)"
+  }),
+  credit_slug: SlugSchema.meta({
+    title: "Credit Slug",
+    description: "Slug of the credit type for this certificate",
+    examples: ["carbon", "organic"]
+  }),
+  mass_id: MassIDReferenceWithContractSchema
+}).meta({
+  title: "Certificate",
+  description: "Certificate associated with the purchase"
+});
+var CreditPurchaseReceiptParticipantRewardSchema = zod.z.strictObject({
+  id_hash: Sha256HashSchema.meta({
+    title: "Participant ID Hash",
+    description: "Hash representing the participant identifier (SHA-256 hex string)"
+  }),
+  participant_name: ParticipantNameSchema.meta({
+    title: "Participant Name",
+    description: "Legal name of the participant receiving the reward"
+  }),
+  roles: uniqueArrayItems(
+    ParticipantRoleSchema,
+    "Participant roles must be unique"
+  ).min(1).meta({
+    title: "Participant Roles",
+    description: "Roles the participant has in the supply chain"
+  }),
+  usdc_amount: NonNegativeFloatSchema.meta({
+    title: "USDC Reward Amount",
+    description: "USDC amount allocated to this participant"
+  })
+}).meta({
+  title: "Participant Reward",
+  description: "Reward distribution for a participant"
+});
+var CreditPurchaseReceiptRetirementReceiptSchema = zod.z.strictObject({
+  token_id: TokenIdSchema.meta({
+    title: "Retirement Receipt Token ID",
+    description: "Token ID of the retirement receipt NFT"
+  }),
+  external_id: ExternalIdSchema.meta({
+    title: "Retirement Receipt External ID",
+    description: "External identifier for the retirement receipt"
+  }),
+  external_url: ExternalUrlSchema.meta({
+    title: "Retirement Receipt External URL",
+    description: "External URL for the retirement receipt"
+  }),
+  uri: IpfsUriSchema.meta({
+    title: "Retirement Receipt URI",
+    description: "IPFS URI for the retirement receipt metadata"
+  }),
+  smart_contract: SmartContractSchema
+}).meta({
+  title: "Retirement Receipt Reference",
+  description: "Reference to the retirement receipt NFT"
+});
+var CreditPurchaseReceiptRetirementSchema = zod.z.strictObject({
+  beneficiary_id: ExternalIdSchema.meta({
+    title: "Retirement Beneficiary ID",
+    description: "UUID identifying the beneficiary of the retirement (bytes16 normalized to UUID)"
+  }),
+  retirement_receipt: CreditPurchaseReceiptRetirementReceiptSchema.optional()
+}).meta({
+  title: "Retirement",
+  description: "Immediate retirement details performed as part of purchase"
+});
+var EPSILON = 1e-9;
+function nearlyEqual(a, b) {
+  return Math.abs(a - b) <= EPSILON;
+}
+var CreditPurchaseReceiptDataSchema = zod.z.strictObject({
+  summary: CreditPurchaseReceiptSummarySchema,
+  parties: CreditPurchaseReceiptPartiesSchema,
+  collections: uniqueBy(
+    CreditPurchaseReceiptCollectionSchema,
+    (collection) => collection.slug,
+    "Collection slugs must be unique"
+  ).min(1).meta({
+    title: "Collections",
+    description: "Collections included in the purchase"
+  }),
+  credits: uniqueBy(
+    CreditPurchaseReceiptCreditSchema,
+    (credit) => credit.slug,
+    "Credit slugs must be unique"
+  ).min(1).meta({
+    title: "Credits",
+    description: "Credits included in the purchase"
+  }),
+  certificates: uniqueBy(
+    CreditPurchaseReceiptCertificateSchema,
+    (certificate) => certificate.token_id,
+    "Certificate token_ids must be unique"
+  ).min(1).meta({
+    title: "Certificates",
+    description: "Certificates involved in the purchase"
+  }),
+  participant_rewards: uniqueBy(
+    CreditPurchaseReceiptParticipantRewardSchema,
+    (reward) => reward.id_hash,
+    "Participant id_hash must be unique"
+  ).min(1).meta({
+    title: "Participant Rewards",
+    description: "Rewards distributed to participants in the supply chain for this purchase"
+  }),
+  retirement: CreditPurchaseReceiptRetirementSchema.optional()
+}).superRefine((data, ctx) => {
+  const retirementProvided = Boolean(data.retirement);
+  const creditsWithRetirement = data.credits.reduce(
+    (indices, credit, index) => {
+      if ((credit.retirement_amount ?? 0) > 0) {
+        indices.push(index);
+      }
+      return indices;
+    },
+    []
+  );
+  if (retirementProvided && creditsWithRetirement.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "retirement is present but no credit has retirement_amount greater than 0",
+      path: ["retirement"]
+    });
+  }
+  if (!retirementProvided && creditsWithRetirement.length > 0) {
+    creditsWithRetirement.forEach((index) => {
+      ctx.addIssue({
+        code: "custom",
+        message: "credit retirement_amount greater than 0 requires retirement details",
+        path: ["credits", index, "retirement_amount"]
+      });
+    });
+  }
+  const collectionSlugs = new Set(
+    data.collections.map((collection) => collection.slug)
+  );
+  const creditSlugs = new Set(data.credits.map((credit) => credit.slug));
+  const creditSymbols = new Set(data.credits.map((credit) => credit.symbol));
+  const summaryCreditSymbols = new Set(data.summary.credit_symbols);
+  const summaryCollectionSlugs = new Set(data.summary.collection_slugs);
+  const summaryCertificateTypes = new Set(data.summary.certificate_types);
+  if (data.summary.total_certificates !== data.certificates.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "summary.total_certificates must equal the number of certificates",
+      path: ["summary", "total_certificates"]
+    });
+  }
+  data.summary.credit_symbols.forEach((symbol) => {
+    if (!creditSymbols.has(symbol)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "summary.credit_symbols must reference symbols from credits",
+        path: ["summary", "credit_symbols"]
+      });
+    }
+  });
+  creditSymbols.forEach((symbol) => {
+    if (!summaryCreditSymbols.has(symbol)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "All credit symbols must be listed in summary.credit_symbols",
+        path: ["summary", "credit_symbols"]
+      });
+    }
+  });
+  data.summary.collection_slugs.forEach((slug) => {
+    if (!collectionSlugs.has(slug)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "summary.collection_slugs must reference slugs from collections",
+        path: ["summary", "collection_slugs"]
+      });
+    }
+  });
+  collectionSlugs.forEach((slug) => {
+    if (!summaryCollectionSlugs.has(slug)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "All collection slugs must be listed in summary.collection_slugs",
+        path: ["summary", "collection_slugs"]
+      });
+    }
+  });
+  const certificateTypes = new Set(
+    data.certificates.map((certificate) => certificate.type)
+  );
+  data.summary.certificate_types.forEach((type) => {
+    if (!certificateTypes.has(type)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "summary.certificate_types must reference types present in certificates",
+        path: ["summary", "certificate_types"]
+      });
+    }
+  });
+  certificateTypes.forEach((type) => {
+    if (!summaryCertificateTypes.has(type)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "All certificate types must be listed in summary.certificate_types",
+        path: ["summary", "certificate_types"]
+      });
+    }
+  });
+  const creditPurchaseTotalsBySlug = /* @__PURE__ */ new Map();
+  const creditRetiredTotalsBySlug = /* @__PURE__ */ new Map();
+  const collectionTotalsBySlug = /* @__PURE__ */ new Map();
+  let totalCreditsFromCertificates = 0;
+  data.certificates.forEach((certificate, index) => {
+    if (!collectionSlugs.has(certificate.collection_slug)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "collection_slug must match a collection slug in collections",
+        path: ["certificates", index, "collection_slug"]
+      });
+    }
+    if (!creditSlugs.has(certificate.credit_slug)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "credit_slug must match a credit slug in credits",
+        path: ["certificates", index, "credit_slug"]
+      });
+    }
+    if (certificate.retired_amount > certificate.purchased_amount) {
+      ctx.addIssue({
+        code: "custom",
+        message: "retired_amount cannot exceed purchased_amount",
+        path: ["certificates", index, "retired_amount"]
+      });
+    }
+    if (certificate.purchased_amount > certificate.total_amount) {
+      ctx.addIssue({
+        code: "custom",
+        message: "purchased_amount cannot exceed total_amount",
+        path: ["certificates", index, "purchased_amount"]
+      });
+    }
+    totalCreditsFromCertificates += certificate.purchased_amount;
+    creditPurchaseTotalsBySlug.set(
+      certificate.credit_slug,
+      (creditPurchaseTotalsBySlug.get(certificate.credit_slug) ?? 0) + certificate.purchased_amount
+    );
+    creditRetiredTotalsBySlug.set(
+      certificate.credit_slug,
+      (creditRetiredTotalsBySlug.get(certificate.credit_slug) ?? 0) + certificate.retired_amount
+    );
+    collectionTotalsBySlug.set(
+      certificate.collection_slug,
+      (collectionTotalsBySlug.get(certificate.collection_slug) ?? 0) + certificate.purchased_amount
+    );
+  });
+  const totalCreditsFromCollections = data.collections.reduce(
+    (sum, collection) => sum + collection.credit_amount,
+    0
+  );
+  const totalCreditsFromCredits = data.credits.reduce(
+    (sum, credit) => sum + credit.purchase_amount,
+    0
+  );
+  if (!nearlyEqual(totalCreditsFromCertificates, data.summary.total_credits)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "summary.total_credits must equal sum of certificates.purchased_amount",
+      path: ["summary", "total_credits"]
+    });
+  }
+  if (!nearlyEqual(totalCreditsFromCredits, data.summary.total_credits)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "summary.total_credits must equal sum of credits.purchase_amount",
+      path: ["summary", "total_credits"]
+    });
+  }
+  if (!nearlyEqual(totalCreditsFromCollections, data.summary.total_credits)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "summary.total_credits must equal sum of collections.credit_amount",
+      path: ["summary", "total_credits"]
+    });
+  }
+  data.credits.forEach((credit, index) => {
+    const purchasedTotal = creditPurchaseTotalsBySlug.get(credit.slug) ?? 0;
+    if (!nearlyEqual(credit.purchase_amount, purchasedTotal)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "credit.purchase_amount must equal sum of certificate purchased_amount for the credit slug",
+        path: ["credits", index, "purchase_amount"]
+      });
+    }
+    const retiredTotal = creditRetiredTotalsBySlug.get(credit.slug) ?? 0;
+    const retirementAmount = credit.retirement_amount ?? 0;
+    if (!nearlyEqual(retirementAmount, retiredTotal)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "credit.retirement_amount must equal sum of certificate retired_amount for the credit slug",
+        path: ["credits", index, "retirement_amount"]
+      });
+    }
+  });
+  data.collections.forEach((collection, index) => {
+    const purchasedTotal = collectionTotalsBySlug.get(collection.slug) ?? 0;
+    if (!nearlyEqual(collection.credit_amount, purchasedTotal)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "collection.credit_amount must equal sum of certificate purchased_amount for the collection slug",
+        path: ["collections", index, "credit_amount"]
+      });
+    }
+  });
+  const participantRewardTotal = data.participant_rewards.reduce(
+    (sum, reward) => sum + reward.usdc_amount,
+    0
+  );
+  if (!nearlyEqual(participantRewardTotal, data.summary.total_usdc_amount)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "summary.total_usdc_amount must equal sum of participant_rewards.usdc_amount",
+      path: ["summary", "total_usdc_amount"]
+    });
+  }
+}).meta({
+  title: "Credit Purchase Receipt Data",
+  description: "Complete data structure for a credit purchase receipt"
+});
+var CreditPurchaseReceiptIpfsSchemaMeta = {
+  title: "CreditPurchaseReceipt NFT IPFS Record",
+  description: "Complete CreditPurchaseReceipt NFT IPFS record including attributes and credit purchase data",
+  $id: buildSchemaUrl(
+    "credit-purchase-receipt/credit-purchase-receipt.schema.json"
+  ),
+  version: getSchemaVersionOrDefault()
+};
+var CreditPurchaseReceiptIpfsSchema = NftIpfsSchema.safeExtend({
+  schema: NftIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("CreditPurchaseReceipt").meta({
+      title: "CreditPurchaseReceipt Schema Type",
+      description: "CreditPurchaseReceipt NFT schema type"
+    })
+  }),
+  attributes: CreditPurchaseReceiptAttributesSchema,
+  data: CreditPurchaseReceiptDataSchema
+}).superRefine((value, ctx) => {
+  const attributes = value.attributes;
+  const data = value.data;
+  const attributeByTraitType = new Map(
+    attributes.map((attribute) => [attribute.trait_type, attribute])
+  );
+  const totalCreditsAttribute = attributeByTraitType.get(
+    "Total Credits Purchased"
+  );
+  const totalCreditsAttr = totalCreditsAttribute;
+  if (!totalCreditsAttr) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Total Credits Purchased" is required',
+      path: ["attributes"]
+    });
+  } else if (totalCreditsAttr.value !== data.summary.total_credits) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Total Credits Purchased" must match data.summary.total_credits',
+      path: ["attributes"]
+    });
+  }
+  const totalUsdcAttribute = attributeByTraitType.get("Total USDC Amount");
+  if (!totalUsdcAttribute) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Total USDC Amount" is required',
+      path: ["attributes"]
+    });
+  } else if (totalUsdcAttribute.value !== data.summary.total_usdc_amount) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Total USDC Amount" must match data.summary.total_usdc_amount',
+      path: ["attributes"]
+    });
+  }
+  const certificatesAttribute = attributeByTraitType.get(
+    "Certificates Purchased"
+  );
+  if (!certificatesAttribute) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Certificates Purchased" is required',
+      path: ["attributes"]
+    });
+  } else if (certificatesAttribute.value !== data.summary.total_certificates) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Certificates Purchased" must match data.summary.total_certificates',
+      path: ["attributes"]
+    });
+  }
+  const receiverAttribute = attributeByTraitType.get("Receiver");
+  if (data.parties.receiver.identity?.name && !receiverAttribute) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Receiver" is required when receiver.identity.name is provided',
+      path: ["attributes"]
+    });
+  } else if (receiverAttribute && data.parties.receiver.identity?.name && receiverAttribute.value !== data.parties.receiver.identity.name) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Receiver" must match receiver.identity.name',
+      path: ["attributes"]
+    });
+  }
+  const purchaseDateAttribute = attributeByTraitType.get("Purchase Date");
+  const purchaseDateAttr = purchaseDateAttribute;
+  if (!purchaseDateAttr) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'Attribute "Purchase Date" is required',
+      path: ["attributes"]
+    });
+  } else {
+    const purchaseDateMs = Date.parse(
+      `${data.summary.purchase_date}T00:00:00.000Z`
+    );
+    if (Number.isNaN(purchaseDateMs)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "data.summary.purchase_date must be a valid date string",
+        path: ["data", "summary", "purchase_date"]
+      });
+    } else if (purchaseDateAttr.value !== purchaseDateMs) {
+      ctx.addIssue({
+        code: "custom",
+        message: 'Attribute "Purchase Date" must match data.summary.purchase_date as a Unix timestamp in milliseconds',
+        path: ["attributes"]
+      });
+    }
+  }
+  data.credits.forEach((credit) => {
+    const creditAttribute = attributeByTraitType.get(credit.symbol);
+    if (!creditAttribute) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for credit symbol ${credit.symbol} is required`,
+        path: ["attributes"]
+      });
+      return;
+    }
+    if (creditAttribute.value !== credit.purchase_amount) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for credit symbol ${credit.symbol} must match credit.purchase_amount`,
+        path: ["attributes"]
+      });
+    }
+  });
+  data.collections.forEach((collection) => {
+    const collectionAttribute = attributeByTraitType.get(collection.name);
+    if (!collectionAttribute) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for collection ${collection.name} is required`,
+        path: ["attributes"]
+      });
+      return;
+    }
+    if (collectionAttribute.value !== collection.credit_amount) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Attribute for collection ${collection.name} must match collection.credit_amount`,
+        path: ["attributes"]
+      });
+    }
+  });
+}).meta(CreditPurchaseReceiptIpfsSchemaMeta);
+var CollectionSchemaMeta = {
+  title: "Collection IPFS Record",
+  description: "Collection metadata stored in IPFS, extending the base schema with collection-specific fields required for NFT collection definitions in Carrot's ecosystem",
+  $id: buildSchemaUrl("collection/collection.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var CollectionSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("Collection").meta({
+      title: "Collection Schema Type",
+      description: "Collection schema type"
+    })
+  }),
+  name: CollectionNameSchema,
+  slug: CollectionSlugSchema.optional(),
+  image: IpfsUriSchema.meta({
+    title: "Collection Image",
+    description: "IPFS URI pointing to the collection's visual representation",
+    examples: ["ipfs://QmCollectionImageHash/collection-icon.png"]
+  }),
+  description: zod.z.string().min(50).max(1e3).meta({
+    title: "Collection Description",
+    description: "Comprehensive description of the collection, its purpose, and context",
+    examples: [
+      "Cold Start is a limited-edition collection created for early supporters of BOLD - Breakthrough in Organic Landfill Diversion. This purchase contributes to reducing global waste and promoting circularity, with funds distributed via smart contract to local recycling operations and communities."
+    ]
+  })
+}).meta(CollectionSchemaMeta);
+var CreditSchemaMeta = {
+  title: "Credit IPFS Record",
+  description: "Credit token metadata stored in IPFS, extending the base schema with ERC20-specific details",
+  $id: buildSchemaUrl("credit/credit.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var CreditSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("Credit").meta({
+      title: "Credit Schema Type",
+      description: "Credit schema type"
+    })
+  }),
+  symbol: TokenSymbolSchema,
+  slug: SlugSchema.meta({
+    title: "Token Slug",
+    description: "URL-friendly identifier for the token",
+    examples: ["carbon"]
+  }).optional(),
+  name: NonEmptyStringSchema.meta({
+    title: "Token Name",
+    description: "Full human-readable name of the ERC20 token",
+    examples: ["Carrot Carbon"]
+  }),
+  decimals: zod.z.number().int().min(0).max(18).meta({
+    title: "Token Decimals",
+    description: "Number of decimal places for the ERC20 token",
+    examples: [18]
+  }),
+  image: IpfsUriSchema.meta({
+    title: "Token Image",
+    description: "IPFS URI pointing to the token's visual representation image",
+    examples: ["ipfs://QmTokenImageHash/credit-icon.png"]
+  }),
+  description: zod.z.string().min(50).max(1e3).meta({
+    title: "Token Description",
+    description: "Comprehensive description of the credit token, its purpose, and impact",
+    examples: [
+      "Carrot Carbon (C-CARB) represents verified carbon emissions reductions from organic waste composting projects. Each token equals one metric ton of CO2 equivalent prevented from entering the atmosphere through sustainable waste management practices."
+    ]
+  })
+}).meta(CreditSchemaMeta);
+var MethodologyDataSchema = zod.z.strictObject({
+  name: MethodologyNameSchema.meta({
+    title: "Methodology Name",
+    description: "Full official name of the methodology"
+  }),
+  short_name: NonEmptyStringSchema.max(50).meta({
+    title: "Methodology Short Name",
+    description: "Abbreviated name for UI display and references",
+    examples: ["BOLD Carbon", "BOLD Recycling"]
+  }),
+  slug: SlugSchema.meta({
+    title: "Methodology Slug",
+    description: "URL-friendly identifier for the methodology",
+    examples: ["bold-carbon-ch4", "bold-recycling"]
+  }),
+  version: SemanticVersionSchema.meta({
+    title: "Methodology Version",
+    description: "Version of the methodology"
+  }),
+  description: zod.z.string().min(50).max(2e3).meta({
+    title: "Methodology Description",
+    description: "Comprehensive methodology description including purpose, scope, and implementation approach"
+  }),
+  revision_date: IsoDateSchema.meta({
+    title: "Revision Date",
+    description: "ISO 8601 date of the last revision to this methodology"
+  }),
+  publication_date: IsoDateSchema.meta({
+    title: "Publication Date",
+    description: "ISO 8601 date of the original publication of this methodology"
+  }),
+  methodology_pdf: IpfsUriSchema.meta({
+    title: "Methodology PDF",
+    description: "IPFS URI pointing to the complete methodology PDF document"
+  }),
+  mass_id_audit_rules: AuditRuleDefinitionsSchema.meta({
+    title: "MassID Audit Rules",
+    description: "Audit rules that must be executed to check MassID compliance with the methodology"
+  })
+}).meta({
+  title: "Methodology Data",
+  description: "Methodology-specific data including audit rules"
+});
+
+// src/methodology/methodology.schema.ts
+var MethodologySchemaMeta = {
+  title: "Methodology IPFS Record",
+  description: "Methodology metadata stored in IPFS, extending the base schema with methodology data and audit rules",
+  $id: buildSchemaUrl("methodology/methodology.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var MethodologySchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("Methodology").meta({
+      title: "Methodology Schema Type",
+      description: "Methodology schema type"
+    })
+  }),
+  data: MethodologyDataSchema
+}).meta(MethodologySchemaMeta);
+var MassIDAuditSummarySchema = zod.z.strictObject({
+  audit_date: IsoDateSchema.meta({
+    title: "Audit Date",
+    description: "Date when the audit was completed"
+  }),
+  methodology_compliance: MethodologyComplianceSchema.meta({
+    title: "Methodology Compliance",
+    description: "Overall outcome of the audit process"
+  }),
+  total_rules_executed: NonNegativeIntegerSchema.meta({
+    title: "Total Rules Executed",
+    description: "Total number of audit rules executed"
+  }),
+  passed_rules: NonNegativeIntegerSchema.meta({
+    title: "Passed Rules Count",
+    description: "Number of rules that passed verification"
+  }),
+  failed_rules: NonNegativeIntegerSchema.meta({
+    title: "Failed Rules Count",
+    description: "Number of rules that failed verification"
+  })
+}).meta({
+  title: "Audit Summary",
+  description: "Summary of audit execution results"
+});
+var MassIDAuditDataSchema = zod.z.strictObject({
+  methodology: MethodologyReferenceSchema,
+  mass_id: MassIDReferenceSchema,
+  gas_id: GasIDReferenceSchema,
+  audit_summary: MassIDAuditSummarySchema,
+  rules_execution_results: AuditRuleExecutionResultsSchema
+}).meta({
+  title: "MassID Audit Data",
+  description: "Complete data structure for MassID Audit records"
+});
+
+// src/mass-id-audit/mass-id-audit.schema.ts
+var MassIDAuditSchemaMeta = {
+  title: "MassID Audit IPFS Record",
+  description: "MassID audit metadata stored in IPFS, extending the base schema with audit results and references",
+  $id: buildSchemaUrl("mass-id-audit/mass-id-audit.schema.json"),
+  version: getSchemaVersionOrDefault()
+};
+var MassIDAuditSchema = BaseIpfsSchema.safeExtend({
+  schema: BaseIpfsSchema.shape.schema.safeExtend({
+    type: zod.z.literal("MassID Audit").meta({
+      title: "MassID Audit Schema Type",
+      description: "MassID Audit schema type"
+    })
+  }),
+  data: MassIDAuditDataSchema
+}).meta(MassIDAuditSchemaMeta);
 
 exports.AccreditedParticipantSchema = AccreditedParticipantSchema;
 exports.AccreditedParticipantsSchema = AccreditedParticipantsSchema;
 exports.AdministrativeDivisionSchema = AdministrativeDivisionSchema;
 exports.AuditReferenceSchema = AuditReferenceSchema;
+exports.AuditRuleDefinitionSchema = AuditRuleDefinitionSchema;
+exports.AuditRuleDefinitionsSchema = AuditRuleDefinitionsSchema;
+exports.AuditRuleExecutionResultSchema = AuditRuleExecutionResultSchema;
+exports.AuditRuleExecutionResultsSchema = AuditRuleExecutionResultsSchema;
 exports.BaseIpfsSchema = BaseIpfsSchema;
 exports.BlockchainChainIdSchema = BlockchainChainIdSchema;
+exports.BlockchainNetworkNameSchema = BlockchainNetworkNameSchema;
+exports.CollectionNameSchema = CollectionNameSchema;
+exports.CollectionSchema = CollectionSchema;
+exports.CollectionSchemaMeta = CollectionSchemaMeta;
+exports.CollectionSlugSchema = CollectionSlugSchema;
 exports.CoordinatesSchema = CoordinatesSchema;
 exports.CountryNameSchema = CountryNameSchema;
 exports.CreditAmountAttributeSchema = CreditAmountAttributeSchema;
 exports.CreditAmountSchema = CreditAmountSchema;
+exports.CreditPurchaseReceiptAttributesSchema = CreditPurchaseReceiptAttributesSchema;
+exports.CreditPurchaseReceiptDataSchema = CreditPurchaseReceiptDataSchema;
+exports.CreditPurchaseReceiptIpfsSchema = CreditPurchaseReceiptIpfsSchema;
+exports.CreditPurchaseReceiptIpfsSchemaMeta = CreditPurchaseReceiptIpfsSchemaMeta;
+exports.CreditSchema = CreditSchema;
+exports.CreditSchemaMeta = CreditSchemaMeta;
 exports.CreditTypeAttributeSchema = CreditTypeAttributeSchema;
 exports.CreditTypeSchema = CreditTypeSchema;
 exports.DistributionNotesSchema = DistributionNotesSchema;
@@ -1728,6 +2808,9 @@ exports.LatitudeSchema = LatitudeSchema;
 exports.LocationSchema = LocationSchema;
 exports.LongitudeSchema = LongitudeSchema;
 exports.MassIDAttributesSchema = MassIDAttributesSchema;
+exports.MassIDAuditDataSchema = MassIDAuditDataSchema;
+exports.MassIDAuditSchema = MassIDAuditSchema;
+exports.MassIDAuditSchemaMeta = MassIDAuditSchemaMeta;
 exports.MassIDDataSchema = MassIDDataSchema;
 exports.MassIDIpfsSchema = MassIDIpfsSchema;
 exports.MassIDIpfsSchemaMeta = MassIDIpfsSchemaMeta;
@@ -1736,8 +2819,11 @@ exports.MassIDReferenceSchema = MassIDReferenceSchema;
 exports.MassIDTokenIdAttributeSchema = MassIDTokenIdAttributeSchema;
 exports.MethodologyAttributeSchema = MethodologyAttributeSchema;
 exports.MethodologyComplianceSchema = MethodologyComplianceSchema;
+exports.MethodologyDataSchema = MethodologyDataSchema;
 exports.MethodologyNameSchema = MethodologyNameSchema;
 exports.MethodologyReferenceSchema = MethodologyReferenceSchema;
+exports.MethodologySchema = MethodologySchema;
+exports.MethodologySchemaMeta = MethodologySchemaMeta;
 exports.MinutesSchema = MinutesSchema;
 exports.MunicipalitySchema = MunicipalitySchema;
 exports.NftAttributeSchema = NftAttributeSchema;
@@ -1765,6 +2851,8 @@ exports.RewardAllocationSchema = RewardAllocationSchema;
 exports.SemanticVersionSchema = SemanticVersionSchema;
 exports.Sha256HashSchema = Sha256HashSchema;
 exports.SlugSchema = SlugSchema;
+exports.SmartContractAddressSchema = SmartContractAddressSchema;
+exports.SmartContractSchema = SmartContractSchema;
 exports.SourceWasteTypeAttributeSchema = SourceWasteTypeAttributeSchema;
 exports.SourceWeightAttributeSchema = SourceWeightAttributeSchema;
 exports.StringifiedTokenIdSchema = StringifiedTokenIdSchema;