@hypercerts-org/lexicon 0.9.0-beta.0 → 0.10.0-beta.1

package/dist/index.mjs

@@ -1,670 +1,179 @@
 import { Lexicons, ValidationError } from '@atproto/lexicon';
 
-var lexicon$9 = 1;
-var id$i = "app.certified.defs";
-var defs$a = {
-	uri: {
-		type: "string",
-		format: "uri",
-		maxGraphemes: 1000,
-		description: "URI to external data"
-	},
-	smallBlob: {
-		type: "blob",
-		accept: [
-			"*/*"
-		],
-		maxSize: 10485760,
-		description: "Blob to external data (up to 10MB)"
-	},
-	largeBlob: {
-		type: "blob",
-		accept: [
-			"*/*"
-		],
-		maxSize: 104857600,
-		description: "Blob to external data (up to 100MB)"
-	}
-};
-var defsLexicon = {
-	lexicon: lexicon$9,
-	id: id$i,
-	defs: defs$a
-};
-
-var lexicon$8 = 1;
-var id$h = "app.certified.location";
-var defs$9 = {
-	main: {
-		type: "record",
-		description: "A location reference",
-		key: "any",
-		record: {
-			type: "object",
-			required: [
-				"lpVersion",
-				"srs",
-				"locationType",
-				"location",
-				"createdAt"
-			],
-			properties: {
-				lpVersion: {
-					type: "string",
-					description: "The version of the Location Protocol",
-					maxLength: 10
-				},
-				srs: {
-					type: "string",
-					format: "uri",
-					description: "The Spatial Reference System URI (e.g., http://www.opengis.net/def/crs/OGC/1.3/CRS84) that defines the coordinate system.",
-					maxLength: 100
-				},
-				locationType: {
-					type: "string",
-					description: "An identifier for the format of the location data (e.g., coordinate-decimal, geojson-point)",
-					knownValues: [
-						"coordinate-decimal",
-						"geojson-point"
-					],
-					maxLength: 20
-				},
-				location: {
-					type: "union",
-					refs: [
-						"app.certified.defs#uri",
-						"app.certified.defs#smallBlob"
-					],
-					description: "The location of where the work was performed as a URI or blob."
-				},
-				name: {
-					type: "string",
-					description: "Optional name for this location",
-					maxLength: 1000,
-					maxGraphemes: 100
-				},
-				description: {
-					type: "string",
-					description: "Optional description for this location",
-					maxLength: 2000,
-					maxGraphemes: 500
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this record was originally created"
-				}
-			}
-		}
-	}
-};
-var locationLexicon = {
-	lexicon: lexicon$8,
-	id: id$h,
-	defs: defs$9
-};
-
-var lexicon$7 = 1;
-var id$g = "org.hypercerts.claim";
-var defs$8 = {
-	main: {
-		type: "record",
-		description: "A hypercert record tracking impact work.",
-		key: "any",
-		record: {
-			type: "object",
-			required: [
-				"title",
-				"shortDescription",
-				"createdAt",
-				"workScope",
-				"workTimeFrameFrom",
-				"workTimeFrameTo"
-			],
-			properties: {
-				title: {
-					type: "string",
-					description: "Title of the hypercert",
-					maxLength: 256
-				},
-				shortDescription: {
-					type: "string",
-					description: "Short blurb of the impact work done.",
-					maxLength: 3000,
-					maxGraphemes: 300
-				},
-				description: {
-					type: "string",
-					description: "Optional longer description of the impact work done.",
-					maxLength: 30000,
-					maxGraphemes: 3000
-				},
-				image: {
-					type: "union",
-					refs: [
-						"app.certified.defs#uri",
-						"app.certified.defs#smallBlob"
-					],
-					description: "The hypercert visual representation as a URI or blob"
-				},
-				workScope: {
-					type: "string",
-					description: "Scope of the work performed",
-					maxLength: 5000,
-					maxGraphemes: 1000
-				},
-				workTimeFrameFrom: {
-					type: "string",
-					format: "datetime",
-					description: "When the work began"
-				},
-				workTimeFrameTo: {
-					type: "string",
-					format: "datetime",
-					description: "When the work ended"
-				},
-				evidence: {
-					type: "array",
-					description: "Supporting evidence, documentation, or external data URIs",
-					items: {
-						type: "ref",
-						ref: "com.atproto.repo.strongRef",
-						description: "A strong reference to the evidence that supports this impact claim. The record referenced must conform with the org.hypercerts.claim.evidence lexicon"
-					},
-					maxLength: 100
-				},
-				contributions: {
-					type: "array",
-					description: "A strong reference to the contributions done to create the impact in the hypercerts. The record referenced must conform with the lexicon org.hypercerts.claim.contributions",
-					items: {
-						type: "ref",
-						ref: "com.atproto.repo.strongRef"
-					}
-				},
-				rights: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to the rights that this hypercert has. The record referenced must conform with the lexicon org.hypercerts.claim.rights"
-				},
-				location: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to the location where the work for done hypercert was located. The record referenced must conform with the lexicon org.hypercerts.claim.location"
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this record was originally created"
-				}
-			}
-		}
-	}
-};
-var claimLexicon = {
-	lexicon: lexicon$7,
-	id: id$g,
-	defs: defs$8
-};
-
-var lexicon$6 = 1;
-var id$f = "org.hypercerts.claim.contribution";
-var defs$7 = {
-	main: {
-		type: "record",
-		description: "A contribution made toward a hypercert's impact.",
-		key: "any",
-		record: {
-			type: "object",
-			required: [
-				"hypercert",
-				"contributors",
-				"createdAt"
-			],
-			properties: {
-				hypercert: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to the hypercert this contribution is for. The record referenced must conform with the lexicon org.hypercerts.claim."
-				},
-				role: {
-					type: "string",
-					description: "Role or title of the contributor(s).",
-					maxLength: 100
-				},
-				contributors: {
-					type: "array",
-					description: "List of the contributors (names, pseudonyms, or DIDs). If multiple contributors are stored in the same hypercertContribution, then they would have the exact same role.",
-					items: {
-						type: "string"
-					}
-				},
-				description: {
-					type: "string",
-					description: "What the contribution concretely achieved",
-					maxLength: 2000,
-					maxGraphemes: 500
-				},
-				workTimeframeFrom: {
-					type: "string",
-					format: "datetime",
-					description: "When this contribution started. This should be a subset of the hypercert timeframe."
-				},
-				workTimeframeTo: {
-					type: "string",
-					format: "datetime",
-					description: "When this contribution finished.  This should be a subset of the hypercert timeframe."
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this record was originally created"
-				}
-			}
-		}
-	}
-};
-var contributionLexicon = {
-	lexicon: lexicon$6,
-	id: id$f,
-	defs: defs$7
-};
-
-var lexicon$5 = 1;
-var id$e = "org.hypercerts.claim.evaluation";
-var defs$6 = {
-	main: {
-		type: "record",
-		description: "An evaluation of a hypercert or other claim",
-		key: "tid",
-		record: {
-			type: "object",
-			required: [
-				"subject",
-				"evaluators",
-				"summary",
-				"createdAt"
-			],
-			properties: {
-				subject: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to the evaluated claim. (e.g measurement, hypercert, contribution, etc)"
-				},
-				evaluators: {
-					type: "array",
-					description: "DIDs of the evaluators",
-					items: {
-						type: "string",
-						format: "did"
-					},
-					maxLength: 100
-				},
-				evaluations: {
-					type: "array",
-					description: "Evaluation data (URIs or blobs) containing detailed reports or methodology",
-					items: {
-						type: "union",
-						refs: [
-							"app.certified.defs#uri",
-							"app.certified.defs#smallBlob"
-						]
-					},
-					maxLength: 100
-				},
-				summary: {
-					type: "string",
-					description: "Brief evaluation summary",
-					maxLength: 5000,
-					maxGraphemes: 1000
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this record was originally created"
-				}
-			}
-		}
-	}
-};
-var evaluationLexicon = {
-	lexicon: lexicon$5,
-	id: id$e,
-	defs: defs$6
-};
-
-var lexicon$4 = 1;
-var id$d = "org.hypercerts.claim.evidence";
-var defs$5 = {
-	main: {
-		type: "record",
-		description: "A piece of evidence supporting a hypercert claim",
-		key: "any",
-		record: {
-			type: "object",
-			required: [
-				"content",
-				"shortDescription",
-				"createdAt"
-			],
-			properties: {
-				content: {
-					type: "union",
-					refs: [
-						"app.certified.defs#uri",
-						"app.certified.defs#smallBlob"
-					],
-					description: "A piece of evidence (URI or blobs) supporting a hypercert claim"
-				},
-				title: {
-					type: "string",
-					maxLength: 256,
-					description: "Optional title to describe the nature of the evidence"
-				},
-				shortDescription: {
-					type: "string",
-					maxLength: 3000,
-					maxGraphemes: 300,
-					description: "Short description explaining what this evidence demonstrates or proves"
-				},
-				description: {
-					type: "string",
-					description: "Optional longer description describing the impact claim evidence.",
-					maxLength: 30000,
-					maxGraphemes: 3000
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this hypercert claim was originally created"
-				}
-			}
-		}
-	}
-};
-var evidenceLexicon = {
-	lexicon: lexicon$4,
-	id: id$d,
-	defs: defs$5
-};
-
-var lexicon$3 = 1;
-var id$c = "org.hypercerts.claim.measurement";
-var defs$4 = {
-	main: {
-		type: "record",
-		description: "External measurement data supporting a hypercert claim",
-		key: "tid",
-		record: {
-			type: "object",
-			required: [
-				"hypercert",
-				"measurers",
-				"metric",
-				"value",
-				"createdAt"
-			],
-			properties: {
-				hypercert: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to the hypercert that this measurement is for. The record referenced must conform with the lexicon org.hypercerts.claim."
-				},
-				measurers: {
-					type: "array",
-					description: "DIDs of the entity (or entities) that measured this data",
-					items: {
-						type: "string",
-						format: "did"
-					},
-					maxLength: 100
-				},
-				metric: {
-					type: "string",
-					description: "The metric being measured",
-					maxLength: 500
-				},
-				value: {
-					type: "string",
-					description: "The measured value",
-					maxLength: 500
-				},
-				measurementMethodURI: {
-					type: "string",
-					format: "uri",
-					description: "URI to methodology documentation, standard protocol, or measurement procedure"
-				},
-				evidenceURI: {
-					type: "array",
-					description: "URIs to supporting evidence or data",
-					items: {
-						type: "string",
-						format: "uri"
-					},
-					maxLength: 50
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this record was originally created"
-				}
-			}
-		}
-	}
-};
-var measurementLexicon = {
-	lexicon: lexicon$3,
-	id: id$c,
-	defs: defs$4
-};
-
-var lexicon$2 = 1;
-var id$b = "org.hypercerts.claim.rights";
-var defs$3 = {
-	main: {
-		type: "record",
-		description: "Describes the rights that a user has with a hypercert, such as whether it can be sold, transferred, and under what conditions.",
-		key: "any",
-		record: {
-			type: "object",
-			required: [
-				"rightsName",
-				"rightsType",
-				"rightsDescription",
-				"createdAt"
-			],
-			properties: {
-				rightsName: {
-					type: "string",
-					description: "Full name of the rights",
-					maxLength: 100
-				},
-				rightsType: {
-					type: "string",
-					description: "Short rights identifier for easier search",
-					maxLength: 10
-				},
-				rightsDescription: {
-					type: "string",
-					description: "Description of the rights of this hypercert"
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this record was originally created"
-				}
-			}
-		}
-	}
-};
-var rightsLexicon = {
-	lexicon: lexicon$2,
-	id: id$b,
-	defs: defs$3
-};
-
-var lexicon$1 = 1;
-var id$a = "com.atproto.repo.strongRef";
-var description = "A URI with a content-hash fingerprint.";
-var defs$2 = {
-	main: {
-		type: "object",
-		required: [
-			"uri",
-			"cid"
-		],
-		properties: {
-			uri: {
-				type: "string",
-				format: "at-uri"
-			},
-			cid: {
-				type: "string",
-				format: "cid"
-			}
-		}
-	}
-};
-var strongRef$1 = {
-	lexicon: lexicon$1,
-	id: id$a,
-	description: description,
-	defs: defs$2
-};
-
-var lexicon = 1;
-var id$9 = "org.hypercerts.collection";
-var defs$1 = {
-	main: {
-		type: "record",
-		description: "A collection/group of hypercerts that have a specific property.",
-		key: "tid",
-		record: {
-			type: "object",
-			required: [
-				"title",
-				"claims",
-				"createdAt"
-			],
-			properties: {
-				title: {
-					type: "string",
-					description: "The title of this collection",
-					maxLength: 800,
-					maxGraphemes: 80
-				},
-				shortDescription: {
-					type: "string",
-					maxLength: 3000,
-					maxGraphemes: 300,
-					description: "A short description of this collection"
-				},
-				coverPhoto: {
-					type: "union",
-					refs: [
-						"app.certified.defs#uri",
-						"app.certified.defs#smallBlob"
-					],
-					description: "The cover photo of this collection (either in URI format or in a blob)."
-				},
-				claims: {
-					type: "array",
-					description: "Array of claims with their associated weights in this collection",
-					items: {
-						type: "ref",
-						ref: "#claimItem"
-					}
-				},
-				createdAt: {
-					type: "string",
-					format: "datetime",
-					description: "Client-declared timestamp when this record was originally created"
-				}
-			}
-		}
-	},
-	claimItem: {
-		type: "object",
-		required: [
-			"claim",
-			"weight"
-		],
-		properties: {
-			claim: {
-				type: "ref",
-				ref: "com.atproto.repo.strongRef",
-				description: "A strong reference to a hypercert claim record. This claim must conform to the lexicon org.hypercerts.claim.record"
-			},
-			weight: {
-				type: "string",
-				description: "The weight/importance of this hypercert claim in the collection (a percentage from 0-100, stored as a string to avoid float precision issues). The total claim weights should add up to 100."
-			}
-		}
-	}
-};
-var collectionLexicon = {
-	lexicon: lexicon,
-	id: id$9,
-	defs: defs$1
-};
-
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-function isObject(v) {
-    return v != null && typeof v === 'object';
-}
-function is$type($type, id, hash) {
-    return hash === 'main'
-        ? $type === id
-        : // $type === `${id}#${hash}`
-            typeof $type === 'string' &&
-                $type.length === id.length + 1 + hash.length &&
-                $type.charCodeAt(id.length) === 35 /* '#' */ &&
-                $type.startsWith(id) &&
-                $type.endsWith(hash);
-}
-function is$typed$9(v, id, hash) {
-    return isObject(v) && '$type' in v && is$type(v.$type, id, hash);
-}
-function maybe$typed(v, id, hash) {
-    return (isObject(v) &&
-        ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true));
-}
-/**
- * Utility function that allows to convert a "validate*" utility function into a
- * type predicate.
- */
-function asPredicate(validate) {
-    return function (v) {
-        return validate(v).success;
-    };
-}
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+function isObject(v) {
+    return v != null && typeof v === 'object';
+}
+function is$type($type, id, hash) {
+    return hash === 'main'
+        ? $type === id
+        : // $type === `${id}#${hash}`
+            typeof $type === 'string' &&
+                $type.length === id.length + 1 + hash.length &&
+                $type.charCodeAt(id.length) === 35 /* '#' */ &&
+                $type.startsWith(id) &&
+                $type.endsWith(hash);
+}
+function is$typed$f(v, id, hash) {
+    return isObject(v) && '$type' in v && is$type(v.$type, id, hash);
+}
+function maybe$typed(v, id, hash) {
+    return (isObject(v) &&
+        ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true));
+}
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+function asPredicate(validate) {
+    return function (v) {
+        return validate(v).success;
+    };
+}
 
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
 const schemaDict = {
+    AppCertifiedBadgeAward: {
+        lexicon: 1,
+        id: 'app.certified.badge.award',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'Records a badge award to a user, project, or activity claim.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['badge', 'subject', 'createdAt'],
+                    properties: {
+                        badge: {
+                            type: 'ref',
+                            ref: 'lex:app.certified.badge.definition',
+                            description: 'Reference to the badge definition for this award.',
+                        },
+                        subject: {
+                            type: 'union',
+                            description: 'Entity the badge award is for (either an account DID or any specific AT Protocol record), e.g. a user, a project, or a specific activity claim.',
+                            refs: [
+                                'lex:app.certified.defs#did',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                        },
+                        note: {
+                            type: 'string',
+                            description: 'Optional statement explaining the reason for this badge award.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    AppCertifiedBadgeDefinition: {
+        lexicon: 1,
+        id: 'app.certified.badge.definition',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'Defines a badge that can be awarded via badge award records to users, projects, or activity claims.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['title', 'badgeType', 'icon', 'createdAt'],
+                    properties: {
+                        badgeType: {
+                            type: 'string',
+                            description: 'Category of the badge (e.g. endorsement, participation, affiliation).',
+                        },
+                        title: {
+                            type: 'string',
+                            description: 'Human-readable title of the badge.',
+                        },
+                        icon: {
+                            type: 'blob',
+                            description: 'Icon representing the badge, stored as a blob for compact visual display.',
+                            accept: [
+                                'image/png',
+                                'image/jpeg',
+                                'image/webp',
+                                'image/svg+xml',
+                            ],
+                            maxSize: 1048576,
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Optional short statement describing what the badge represents.',
+                        },
+                        allowedIssuers: {
+                            type: 'array',
+                            description: 'Optional allowlist of DIDs allowed to issue this badge. If omitted, anyone may issue it.',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.certified.defs#did',
+                            },
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    AppCertifiedBadgeResponse: {
+        lexicon: 1,
+        id: 'app.certified.badge.response',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'Recipient response to a badge award.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['badgeAward', 'response', 'createdAt'],
+                    properties: {
+                        badgeAward: {
+                            type: 'ref',
+                            ref: 'lex:app.certified.badge.award',
+                            description: 'Reference to the badge award.',
+                        },
+                        response: {
+                            type: 'string',
+                            enum: ['accepted', 'rejected'],
+                            description: 'The recipient’s response for the badge (accepted or rejected).',
+                        },
+                        weight: {
+                            type: 'string',
+                            description: 'Optional relative weight for accepted badges, assigned by the recipient.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+        },
+    },
     AppCertifiedDefs: {
         lexicon: 1,
         id: 'app.certified.defs',
+        description: 'Common type definitions used across certified protocols.',
         defs: {
-            uri: {
+            did: {
                 type: 'string',
-                format: 'uri',
-                maxGraphemes: 1000,
-                description: 'URI to external data',
-            },
-            smallBlob: {
-                type: 'blob',
-                accept: ['*/*'],
-                maxSize: 10485760,
-                description: 'Blob to external data (up to 10MB)',
-            },
-            largeBlob: {
-                type: 'blob',
-                accept: ['*/*'],
-                maxSize: 104857600,
-                description: 'Blob to external data (up to 100MB)',
+                format: 'did',
+                description: 'A Decentralized Identifier (DID) string.',
             },
         },
     },
@@ -675,7 +184,7 @@ const schemaDict = {
             main: {
                 type: 'record',
                 description: 'A location reference',
-                key: 'any',
+                key: 'tid',
                 record: {
                     type: 'object',
                     required: [
@@ -706,8 +215,8 @@ const schemaDict = {
                         location: {
                             type: 'union',
                             refs: [
-                                'lex:app.certified.defs#uri',
-                                'lex:app.certified.defs#smallBlob',
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallBlob',
                             ],
                             description: 'The location of where the work was performed as a URI or blob.',
                         },
@@ -754,9 +263,9 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaim: {
+    OrgHypercertsClaimActivity: {
         lexicon: 1,
-        id: 'org.hypercerts.claim',
+        id: 'org.hypercerts.claim.activity',
         defs: {
             main: {
                 type: 'record',
@@ -768,14 +277,13 @@ const schemaDict = {
                         'title',
                         'shortDescription',
                         'createdAt',
-                        'workScope',
-                        'workTimeFrameFrom',
-                        'workTimeFrameTo',
+                        'startDate',
+                        'endDate',
                     ],
                     properties: {
                         title: {
                             type: 'string',
-                            description: 'Title of the hypercert',
+                            description: 'Title of the hypercert.',
                             maxLength: 256,
                         },
                         shortDescription: {
@@ -793,40 +301,28 @@ const schemaDict = {
                         image: {
                             type: 'union',
                             refs: [
-                                'lex:app.certified.defs#uri',
-                                'lex:app.certified.defs#smallBlob',
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
                             ],
-                            description: 'The hypercert visual representation as a URI or blob',
+                            description: 'The hypercert visual representation as a URI or image blob.',
                         },
                         workScope: {
-                            type: 'string',
-                            description: 'Scope of the work performed',
-                            maxLength: 5000,
-                            maxGraphemes: 1000,
+                            type: 'ref',
+                            ref: 'lex:org.hypercerts.claim.activity#workScope',
                         },
-                        workTimeFrameFrom: {
+                        startDate: {
                             type: 'string',
                             format: 'datetime',
                             description: 'When the work began',
                         },
-                        workTimeFrameTo: {
+                        endDate: {
                             type: 'string',
                             format: 'datetime',
                             description: 'When the work ended',
                         },
-                        evidence: {
-                            type: 'array',
-                            description: 'Supporting evidence, documentation, or external data URIs',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:com.atproto.repo.strongRef',
-                                description: 'A strong reference to the evidence that supports this impact claim. The record referenced must conform with the org.hypercerts.claim.evidence lexicon',
-                            },
-                            maxLength: 100,
-                        },
                         contributions: {
                             type: 'array',
-                            description: 'A strong reference to the contributions done to create the impact in the hypercerts. The record referenced must conform with the lexicon org.hypercerts.claim.contributions',
+                            description: 'A strong reference to the contributions done to create the impact in the hypercerts. The record referenced must conform with the lexicon org.hypercerts.claim.contribution.',
                             items: {
                                 type: 'ref',
                                 ref: 'lex:com.atproto.repo.strongRef',
@@ -835,12 +331,116 @@ const schemaDict = {
                         rights: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the rights that this hypercert has. The record referenced must conform with the lexicon org.hypercerts.claim.rights',
+                            description: 'A strong reference to the rights that this hypercert has. The record referenced must conform with the lexicon org.hypercerts.claim.rights.',
                         },
                         location: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the location where the work for done hypercert was located. The record referenced must conform with the lexicon org.hypercerts.claim.location',
+                            description: 'A strong reference to the location where the activity was performed. The record referenced must conform with the lexicon app.certified.location.',
+                        },
+                        project: {
+                            type: 'string',
+                            format: 'at-uri',
+                            description: 'A reference (AT-URI) to the project record that this activity is part of. The record referenced must conform with the lexicon org.hypercerts.claim.project. This activity must also be referenced by the project, establishing a bidirectional link.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+            workScope: {
+                type: 'object',
+                description: 'Logical scope of the work using label-based conditions. All labels in `withinAllOf` must apply; at least one label in `withinAnyOf` must apply if provided; no label in `withinNoneOf` may apply.',
+                properties: {
+                    withinAllOf: {
+                        type: 'array',
+                        description: 'Labels that MUST all hold for the scope to apply.',
+                        items: {
+                            type: 'string',
+                        },
+                        maxLength: 100,
+                    },
+                    withinAnyOf: {
+                        type: 'array',
+                        description: 'Labels of which AT LEAST ONE must hold (optional). If omitted or empty, imposes no additional condition.',
+                        items: {
+                            type: 'string',
+                        },
+                        maxLength: 100,
+                    },
+                    withinNoneOf: {
+                        type: 'array',
+                        description: 'Labels that MUST NOT hold for the scope to apply.',
+                        items: {
+                            type: 'string',
+                        },
+                        maxLength: 100,
+                    },
+                },
+            },
+            activityWeight: {
+                type: 'object',
+                required: ['activity', 'weight'],
+                properties: {
+                    activity: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                        description: 'A strong reference to a hypercert activity record. This activity must conform to the lexicon org.hypercerts.claim.activity',
+                    },
+                    weight: {
+                        type: 'string',
+                        description: 'The relative weight/importance of this hypercert activity (stored as a string to avoid float precision issues). Weights can be any positive numeric values and do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsClaimCollection: {
+        lexicon: 1,
+        id: 'org.hypercerts.claim.collection',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'A collection/group of hypercerts that have a specific property.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['title', 'activities', 'createdAt'],
+                    properties: {
+                        title: {
+                            type: 'string',
+                            description: 'The title of this collection',
+                            maxLength: 800,
+                            maxGraphemes: 80,
+                        },
+                        shortDescription: {
+                            type: 'string',
+                            maxLength: 3000,
+                            maxGraphemes: 300,
+                            description: 'A short description of this collection',
+                        },
+                        avatar: {
+                            type: 'blob',
+                            description: 'Primary avatar image representing this collection across apps and views; typically a square image.',
+                            accept: ['image/png', 'image/jpeg'],
+                            maxSize: 1000000,
+                        },
+                        coverPhoto: {
+                            type: 'blob',
+                            description: 'The cover photo of this collection.',
+                            accept: ['image/png', 'image/jpeg'],
+                            maxSize: 1000000,
+                        },
+                        activities: {
+                            type: 'array',
+                            description: 'Array of activities with their associated weights in this collection',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:org.hypercerts.claim.activity#activityWeight',
+                            },
                         },
                         createdAt: {
                             type: 'string',
@@ -859,16 +459,11 @@ const schemaDict = {
             main: {
                 type: 'record',
                 description: "A contribution made toward a hypercert's impact.",
-                key: 'any',
+                key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['hypercert', 'contributors', 'createdAt'],
+                    required: ['contributors', 'createdAt'],
                     properties: {
-                        hypercert: {
-                            type: 'ref',
-                            ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the hypercert this contribution is for. The record referenced must conform with the lexicon org.hypercerts.claim.',
-                        },
                         role: {
                             type: 'string',
                             description: 'Role or title of the contributor(s).',
@@ -887,12 +482,12 @@ const schemaDict = {
                             maxLength: 2000,
                             maxGraphemes: 500,
                         },
-                        workTimeframeFrom: {
+                        startDate: {
                             type: 'string',
                             format: 'datetime',
                             description: 'When this contribution started. This should be a subset of the hypercert timeframe.',
                         },
-                        workTimeframeTo: {
+                        endDate: {
                             type: 'string',
                             format: 'datetime',
                             description: 'When this contribution finished.  This should be a subset of the hypercert timeframe.',
@@ -911,46 +506,84 @@ const schemaDict = {
         lexicon: 1,
         id: 'org.hypercerts.claim.evaluation',
         defs: {
+            score: {
+                type: 'object',
+                description: 'Overall score for an evaluation on a numeric scale.',
+                required: ['min', 'max', 'value'],
+                properties: {
+                    min: {
+                        type: 'integer',
+                        description: 'Minimum value of the scale, e.g. 0 or 1.',
+                    },
+                    max: {
+                        type: 'integer',
+                        description: 'Maximum value of the scale, e.g. 5 or 10.',
+                    },
+                    value: {
+                        type: 'integer',
+                        description: 'Score within the inclusive range [min, max].',
+                    },
+                },
+            },
             main: {
                 type: 'record',
-                description: 'An evaluation of a hypercert or other claim',
+                description: 'An evaluation of a hypercert record (e.g. an activity and its impact).',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['subject', 'evaluators', 'summary', 'createdAt'],
+                    required: ['evaluators', 'summary', 'createdAt'],
                     properties: {
                         subject: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the evaluated claim. (e.g measurement, hypercert, contribution, etc)',
+                            description: 'A strong reference to what is being evaluated. (e.g activity, measurement, contribution, etc.)',
                         },
                         evaluators: {
                             type: 'array',
                             description: 'DIDs of the evaluators',
                             items: {
-                                type: 'string',
-                                format: 'did',
+                                type: 'ref',
+                                ref: 'lex:app.certified.defs#did',
                             },
-                            maxLength: 100,
+                            maxLength: 1000,
                         },
-                        evaluations: {
+                        content: {
                             type: 'array',
                             description: 'Evaluation data (URIs or blobs) containing detailed reports or methodology',
                             items: {
                                 type: 'union',
                                 refs: [
-                                    'lex:app.certified.defs#uri',
-                                    'lex:app.certified.defs#smallBlob',
+                                    'lex:org.hypercerts.defs#uri',
+                                    'lex:org.hypercerts.defs#smallBlob',
                                 ],
                             },
                             maxLength: 100,
                         },
+                        measurements: {
+                            type: 'array',
+                            description: 'Optional references to the measurements that contributed to this evaluation. The record(s) referenced must conform with the lexicon org.hypercerts.claim.measurement ',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:com.atproto.repo.strongRef',
+                            },
+                            maxLength: 100,
+                        },
                         summary: {
                             type: 'string',
                             description: 'Brief evaluation summary',
                             maxLength: 5000,
                             maxGraphemes: 1000,
                         },
+                        score: {
+                            type: 'ref',
+                            ref: 'lex:org.hypercerts.claim.evaluation#score',
+                            description: 'Optional overall score for this evaluation on a numeric scale.',
+                        },
+                        location: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'An optional reference for georeferenced evaluations. The record referenced must conform with the lexicon app.certified.location.',
+                        },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
@@ -967,41 +600,51 @@ const schemaDict = {
         defs: {
             main: {
                 type: 'record',
-                description: 'A piece of evidence supporting a hypercert claim',
-                key: 'any',
+                description: 'A piece of evidence related to a hypercert record (e.g. an activity, project, claim, or evaluation). Evidence may support, clarify, or challenge the referenced subject.',
+                key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['content', 'shortDescription', 'createdAt'],
+                    required: ['content', 'title', 'createdAt'],
                     properties: {
+                        subject: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'A strong reference to the record this evidence relates to (e.g. an activity, project, claim, or evaluation).',
+                        },
                         content: {
                             type: 'union',
                             refs: [
-                                'lex:app.certified.defs#uri',
-                                'lex:app.certified.defs#smallBlob',
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallBlob',
                             ],
-                            description: 'A piece of evidence (URI or blobs) supporting a hypercert claim',
+                            description: 'A piece of evidence (URI or blob) related to the subject record; it may support, clarify, or challenge a hypercert claim.',
                         },
                         title: {
                             type: 'string',
                             maxLength: 256,
-                            description: 'Optional title to describe the nature of the evidence',
+                            description: 'Title to describe the nature of the evidence.',
                         },
                         shortDescription: {
                             type: 'string',
                             maxLength: 3000,
                             maxGraphemes: 300,
-                            description: 'Short description explaining what this evidence demonstrates or proves',
+                            description: 'Short description explaining what this evidence shows.',
                         },
                         description: {
                             type: 'string',
-                            description: 'Optional longer description describing the impact claim evidence.',
+                            description: 'Longer description describing the evidence in more detail.',
                             maxLength: 30000,
                             maxGraphemes: 3000,
                         },
+                        relationType: {
+                            type: 'string',
+                            description: 'How this evidence relates to the subject.',
+                            knownValues: ['supports', 'challenges', 'clarifies'],
+                        },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'Client-declared timestamp when this hypercert claim was originally created',
+                            description: 'Client-declared timestamp when this record was originally created',
                         },
                     },
                 },
@@ -1014,23 +657,23 @@ const schemaDict = {
         defs: {
             main: {
                 type: 'record',
-                description: 'External measurement data supporting a hypercert claim',
+                description: 'Measurement data related to a hypercert record (e.g. an activity and its impact).',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['hypercert', 'measurers', 'metric', 'value', 'createdAt'],
+                    required: ['measurers', 'metric', 'value', 'createdAt'],
                     properties: {
-                        hypercert: {
+                        subject: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the hypercert that this measurement is for. The record referenced must conform with the lexicon org.hypercerts.claim.',
+                            description: 'A strong reference to the record this measurement refers to (e.g. an activity, project, or claim).',
                         },
                         measurers: {
                             type: 'array',
                             description: 'DIDs of the entity (or entities) that measured this data',
                             items: {
-                                type: 'string',
-                                format: 'did',
+                                type: 'ref',
+                                ref: 'lex:app.certified.defs#did',
                             },
                             maxLength: 100,
                         },
@@ -1044,20 +687,94 @@ const schemaDict = {
                             description: 'The measured value',
                             maxLength: 500,
                         },
-                        measurementMethodURI: {
+                        methodType: {
+                            type: 'string',
+                            description: 'Short identifier for the measurement methodology',
+                            maxLength: 30,
+                        },
+                        methodURI: {
                             type: 'string',
                             format: 'uri',
                             description: 'URI to methodology documentation, standard protocol, or measurement procedure',
                         },
                         evidenceURI: {
                             type: 'array',
-                            description: 'URIs to supporting evidence or data',
+                            description: 'URIs to related evidence or underlying data (e.g. org.hypercerts.claim.evidence records or raw datasets)',
                             items: {
                                 type: 'string',
                                 format: 'uri',
                             },
                             maxLength: 50,
                         },
+                        location: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'A strong reference to the location where the measurement was taken. The record referenced must conform with the lexicon app.certified.location',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsClaimProject: {
+        lexicon: 1,
+        id: 'org.hypercerts.claim.project',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'A project that can include multiple activities, each of which may be linked to at most one project.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['title', 'shortDescription', 'createdAt'],
+                    properties: {
+                        title: {
+                            type: 'string',
+                            description: 'Title of this project',
+                            maxLength: 800,
+                            maxGraphemes: 80,
+                        },
+                        shortDescription: {
+                            type: 'string',
+                            maxLength: 3000,
+                            maxGraphemes: 300,
+                            description: 'Short summary of this project, suitable for previews and list views.',
+                        },
+                        description: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.pages.linearDocument#main',
+                            description: 'Rich-text description of this project, represented as a Leaflet linear document.',
+                        },
+                        avatar: {
+                            type: 'blob',
+                            description: 'Primary avatar image representing this project across apps and views; typically a square logo or project identity image.',
+                            accept: ['image/png', 'image/jpeg'],
+                            maxSize: 1000000,
+                        },
+                        coverPhoto: {
+                            type: 'blob',
+                            description: 'The cover photo of this project.',
+                            accept: ['image/png', 'image/jpeg'],
+                            maxSize: 1000000,
+                        },
+                        activities: {
+                            type: 'array',
+                            description: 'Array of activities with their associated weights in this project',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:org.hypercerts.claim.activity#activityWeight',
+                            },
+                        },
+                        location: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'A strong reference to a location record describing where the work for this project took place. The referenced record must conform to the app.certified.location lexicon.',
+                        },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
@@ -1074,8 +791,8 @@ const schemaDict = {
         defs: {
             main: {
                 type: 'record',
-                description: 'Describes the rights that a user has with a hypercert, such as whether it can be sold, transferred, and under what conditions.',
-                key: 'any',
+                description: 'Describes the rights that a contributor and/or an owner has, such as whether the hypercert can be sold, transferred, and under what conditions.',
+                key: 'tid',
                 record: {
                     type: 'object',
                     required: [
@@ -1099,6 +816,14 @@ const schemaDict = {
                             type: 'string',
                             description: 'Description of the rights of this hypercert',
                         },
+                        attachment: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallBlob',
+                            ],
+                            description: 'An attachment to define the rights further, e.g. a legal document.',
+                        },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
@@ -1109,243 +834,1589 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsCollection: {
+    OrgHypercertsDefs: {
+        lexicon: 1,
+        id: 'org.hypercerts.defs',
+        defs: {
+            uri: {
+                type: 'object',
+                required: ['uri'],
+                description: 'Object containing a URI to external data',
+                properties: {
+                    uri: {
+                        type: 'string',
+                        format: 'uri',
+                        maxGraphemes: 1024,
+                        description: 'URI to external data',
+                    },
+                },
+            },
+            smallBlob: {
+                type: 'object',
+                required: ['blob'],
+                description: 'Object containing a blob to external data',
+                properties: {
+                    blob: {
+                        type: 'blob',
+                        accept: ['*/*'],
+                        maxSize: 10485760,
+                        description: 'Blob to external data (up to 10MB)',
+                    },
+                },
+            },
+            largeBlob: {
+                type: 'object',
+                required: ['blob'],
+                description: 'Object containing a blob to external data',
+                properties: {
+                    blob: {
+                        type: 'blob',
+                        accept: ['*/*'],
+                        maxSize: 104857600,
+                        description: 'Blob to external data (up to 100MB)',
+                    },
+                },
+            },
+            smallImage: {
+                type: 'object',
+                required: ['image'],
+                description: 'Object containing a small image',
+                properties: {
+                    image: {
+                        type: 'blob',
+                        accept: ['image/jpeg', 'image/jpg', 'image/png', 'image/webp'],
+                        maxSize: 5242880,
+                        description: 'Image (up to 5MB)',
+                    },
+                },
+            },
+            largeImage: {
+                type: 'object',
+                required: ['image'],
+                description: 'Object containing a large image',
+                properties: {
+                    image: {
+                        type: 'blob',
+                        accept: ['image/jpeg', 'image/jpg', 'image/png', 'image/webp'],
+                        maxSize: 10485760,
+                        description: 'Image (up to 10MB)',
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsFundingReceipt: {
         lexicon: 1,
-        id: 'org.hypercerts.collection',
+        id: 'org.hypercerts.funding.receipt',
         defs: {
             main: {
                 type: 'record',
-                description: 'A collection/group of hypercerts that have a specific property.',
+                description: 'Records a funding receipt for a payment from one user to another user. It may be recorded by the recipient, by the sender, or by a third party. The sender may remain anonymous.',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['title', 'claims', 'createdAt'],
+                    required: ['from', 'to', 'amount', 'currency', 'createdAt'],
                     properties: {
-                        title: {
+                        from: {
+                            type: 'ref',
+                            ref: 'lex:app.certified.defs#did',
+                            description: 'DID of the sender who transferred the funds. Leave empty if sender wants to stay anonymous.',
+                        },
+                        to: {
                             type: 'string',
-                            description: 'The title of this collection',
-                            maxLength: 800,
-                            maxGraphemes: 80,
+                            description: 'The recipient of the funds. Can be identified by DID or a clear-text name.',
                         },
-                        shortDescription: {
+                        amount: {
                             type: 'string',
-                            maxLength: 3000,
-                            maxGraphemes: 300,
-                            description: 'A short description of this collection',
+                            description: 'Amount of funding received.',
                         },
-                        coverPhoto: {
-                            type: 'union',
-                            refs: [
-                                'lex:app.certified.defs#uri',
-                                'lex:app.certified.defs#smallBlob',
-                            ],
-                            description: 'The cover photo of this collection (either in URI format or in a blob).',
+                        currency: {
+                            type: 'string',
+                            description: 'Currency of the payment (e.g. EUR, USD, ETH).',
                         },
-                        claims: {
-                            type: 'array',
-                            description: 'Array of claims with their associated weights in this collection',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:org.hypercerts.collection#claimItem',
-                            },
+                        paymentRail: {
+                            type: 'string',
+                            description: 'How the funds were transferred (e.g. bank_transfer, credit_card, onchain, cash, check, payment_processor).',
+                        },
+                        paymentNetwork: {
+                            type: 'string',
+                            description: 'Optional network within the payment rail (e.g. arbitrum, ethereum, sepa, visa, paypal).',
+                        },
+                        transactionId: {
+                            type: 'string',
+                            description: 'Identifier of the underlying payment transaction (e.g. bank reference, onchain transaction hash, or processor-specific ID). Use paymentNetwork to specify the network where applicable.',
+                        },
+                        for: {
+                            type: 'string',
+                            format: 'at-uri',
+                            description: 'Optional reference to the activity, project, or organization this funding relates to.',
+                        },
+                        notes: {
+                            type: 'string',
+                            description: 'Optional notes or additional context for this funding receipt.',
+                            maxLength: 500,
+                        },
+                        occurredAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Timestamp when the payment occurred.',
                         },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'Client-declared timestamp when this record was originally created',
+                            description: 'Client-declared timestamp when this receipt record was created.',
                         },
                     },
                 },
             },
-            claimItem: {
-                type: 'object',
-                required: ['claim', 'weight'],
-                properties: {
-                    claim: {
-                        type: 'ref',
-                        ref: 'lex:com.atproto.repo.strongRef',
-                        description: 'A strong reference to a hypercert claim record. This claim must conform to the lexicon org.hypercerts.claim.record',
-                    },
-                    weight: {
-                        type: 'string',
-                        description: 'The weight/importance of this hypercert claim in the collection (a percentage from 0-100, stored as a string to avoid float precision issues). The total claim weights should add up to 100.',
-                    },
-                },
-            },
         },
     },
 };
-const schemas = Object.values(schemaDict);
-const lexicons = new Lexicons(schemas);
-function validate$9(v, id, hash, requiredType) {
-    return (requiredType ? is$typed$9 : maybe$typed)(v, id, hash)
-        ? lexicons.validate(`${id}#${hash}`, v)
-        : {
-            success: false,
-            error: new ValidationError(`Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`),
-        };
-}
-const ids = {
-    AppCertifiedDefs: 'app.certified.defs',
-    AppCertifiedLocation: 'app.certified.location',
-    ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
-    OrgHypercertsClaim: 'org.hypercerts.claim',
-    OrgHypercertsClaimContribution: 'org.hypercerts.claim.contribution',
-    OrgHypercertsClaimEvaluation: 'org.hypercerts.claim.evaluation',
-    OrgHypercertsClaimEvidence: 'org.hypercerts.claim.evidence',
-    OrgHypercertsClaimMeasurement: 'org.hypercerts.claim.measurement',
-    OrgHypercertsClaimRights: 'org.hypercerts.claim.rights',
-    OrgHypercertsCollection: 'org.hypercerts.collection',
+const schemas = Object.values(schemaDict);
+const lexicons = new Lexicons(schemas);
+function validate$f(v, id, hash, requiredType) {
+    return (requiredType ? is$typed$f : maybe$typed)(v, id, hash)
+        ? lexicons.validate(`${id}#${hash}`, v)
+        : {
+            success: false,
+            error: new ValidationError(`Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`),
+        };
+}
+const ids = {
+    AppCertifiedBadgeAward: 'app.certified.badge.award',
+    AppCertifiedBadgeDefinition: 'app.certified.badge.definition',
+    AppCertifiedBadgeResponse: 'app.certified.badge.response',
+    AppCertifiedDefs: 'app.certified.defs',
+    AppCertifiedLocation: 'app.certified.location',
+    ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
+    OrgHypercertsClaimActivity: 'org.hypercerts.claim.activity',
+    OrgHypercertsClaimCollection: 'org.hypercerts.claim.collection',
+    OrgHypercertsClaimContribution: 'org.hypercerts.claim.contribution',
+    OrgHypercertsClaimEvaluation: 'org.hypercerts.claim.evaluation',
+    OrgHypercertsClaimEvidence: 'org.hypercerts.claim.evidence',
+    OrgHypercertsClaimMeasurement: 'org.hypercerts.claim.measurement',
+    OrgHypercertsClaimProject: 'org.hypercerts.claim.project',
+    OrgHypercertsClaimRights: 'org.hypercerts.claim.rights',
+    OrgHypercertsDefs: 'org.hypercerts.defs',
+    OrgHypercertsFundingReceipt: 'org.hypercerts.funding.receipt',
+};
+
+var lexicon$f = 1;
+var id$u = "app.certified.badge.award";
+var defs$h = {
+	main: {
+		type: "record",
+		description: "Records a badge award to a user, project, or activity claim.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"badge",
+				"subject",
+				"createdAt"
+			],
+			properties: {
+				badge: {
+					type: "ref",
+					ref: "app.certified.badge.definition",
+					description: "Reference to the badge definition for this award."
+				},
+				subject: {
+					type: "union",
+					description: "Entity the badge award is for (either an account DID or any specific AT Protocol record), e.g. a user, a project, or a specific activity claim.",
+					refs: [
+						"app.certified.defs#did",
+						"com.atproto.repo.strongRef"
+					]
+				},
+				note: {
+					type: "string",
+					description: "Optional statement explaining the reason for this badge award."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var BADGE_AWARD_LEXICON_JSON = {
+	lexicon: lexicon$f,
+	id: id$u,
+	defs: defs$h
+};
+
+var lexicon$e = 1;
+var id$t = "app.certified.badge.definition";
+var defs$g = {
+	main: {
+		type: "record",
+		description: "Defines a badge that can be awarded via badge award records to users, projects, or activity claims.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"title",
+				"badgeType",
+				"icon",
+				"createdAt"
+			],
+			properties: {
+				badgeType: {
+					type: "string",
+					description: "Category of the badge (e.g. endorsement, participation, affiliation)."
+				},
+				title: {
+					type: "string",
+					description: "Human-readable title of the badge."
+				},
+				icon: {
+					type: "blob",
+					description: "Icon representing the badge, stored as a blob for compact visual display.",
+					accept: [
+						"image/png",
+						"image/jpeg",
+						"image/webp",
+						"image/svg+xml"
+					],
+					maxSize: 1048576
+				},
+				description: {
+					type: "string",
+					description: "Optional short statement describing what the badge represents."
+				},
+				allowedIssuers: {
+					type: "array",
+					description: "Optional allowlist of DIDs allowed to issue this badge. If omitted, anyone may issue it.",
+					items: {
+						type: "ref",
+						ref: "app.certified.defs#did"
+					}
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var BADGE_DEFINITION_LEXICON_JSON = {
+	lexicon: lexicon$e,
+	id: id$t,
+	defs: defs$g
+};
+
+var lexicon$d = 1;
+var id$s = "app.certified.badge.response";
+var defs$f = {
+	main: {
+		type: "record",
+		description: "Recipient response to a badge award.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"badgeAward",
+				"response",
+				"createdAt"
+			],
+			properties: {
+				badgeAward: {
+					type: "ref",
+					ref: "app.certified.badge.award",
+					description: "Reference to the badge award."
+				},
+				response: {
+					type: "string",
+					"enum": [
+						"accepted",
+						"rejected"
+					],
+					description: "The recipient’s response for the badge (accepted or rejected)."
+				},
+				weight: {
+					type: "string",
+					description: "Optional relative weight for accepted badges, assigned by the recipient."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var BADGE_RESPONSE_LEXICON_JSON = {
+	lexicon: lexicon$d,
+	id: id$s,
+	defs: defs$f
+};
+
+var lexicon$c = 1;
+var id$r = "app.certified.defs";
+var description$1 = "Common type definitions used across certified protocols.";
+var defs$e = {
+	did: {
+		type: "string",
+		format: "did",
+		description: "A Decentralized Identifier (DID) string."
+	}
+};
+var CERTIFIED_DEFS_LEXICON_JSON = {
+	lexicon: lexicon$c,
+	id: id$r,
+	description: description$1,
+	defs: defs$e
+};
+
+var lexicon$b = 1;
+var id$q = "app.certified.location";
+var defs$d = {
+	main: {
+		type: "record",
+		description: "A location reference",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"lpVersion",
+				"srs",
+				"locationType",
+				"location",
+				"createdAt"
+			],
+			properties: {
+				lpVersion: {
+					type: "string",
+					description: "The version of the Location Protocol",
+					maxLength: 10
+				},
+				srs: {
+					type: "string",
+					format: "uri",
+					description: "The Spatial Reference System URI (e.g., http://www.opengis.net/def/crs/OGC/1.3/CRS84) that defines the coordinate system.",
+					maxLength: 100
+				},
+				locationType: {
+					type: "string",
+					description: "An identifier for the format of the location data (e.g., coordinate-decimal, geojson-point)",
+					knownValues: [
+						"coordinate-decimal",
+						"geojson-point"
+					],
+					maxLength: 20
+				},
+				location: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallBlob"
+					],
+					description: "The location of where the work was performed as a URI or blob."
+				},
+				name: {
+					type: "string",
+					description: "Optional name for this location",
+					maxLength: 1000,
+					maxGraphemes: 100
+				},
+				description: {
+					type: "string",
+					description: "Optional description for this location",
+					maxLength: 2000,
+					maxGraphemes: 500
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var LOCATION_LEXICON_JSON = {
+	lexicon: lexicon$b,
+	id: id$q,
+	defs: defs$d
+};
+
+var lexicon$a = 1;
+var id$p = "com.atproto.repo.strongRef";
+var description = "A URI with a content-hash fingerprint.";
+var defs$c = {
+	main: {
+		type: "object",
+		required: [
+			"uri",
+			"cid"
+		],
+		properties: {
+			uri: {
+				type: "string",
+				format: "at-uri"
+			},
+			cid: {
+				type: "string",
+				format: "cid"
+			}
+		}
+	}
+};
+var STRONGREF_LEXICON_JSON = {
+	lexicon: lexicon$a,
+	id: id$p,
+	description: description,
+	defs: defs$c
+};
+
+var lexicon$9 = 1;
+var id$o = "org.hypercerts.claim.activity";
+var defs$b = {
+	main: {
+		type: "record",
+		description: "A hypercert record tracking impact work.",
+		key: "any",
+		record: {
+			type: "object",
+			required: [
+				"title",
+				"shortDescription",
+				"createdAt",
+				"startDate",
+				"endDate"
+			],
+			properties: {
+				title: {
+					type: "string",
+					description: "Title of the hypercert.",
+					maxLength: 256
+				},
+				shortDescription: {
+					type: "string",
+					description: "Short blurb of the impact work done.",
+					maxLength: 3000,
+					maxGraphemes: 300
+				},
+				description: {
+					type: "string",
+					description: "Optional longer description of the impact work done.",
+					maxLength: 30000,
+					maxGraphemes: 3000
+				},
+				image: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallImage"
+					],
+					description: "The hypercert visual representation as a URI or image blob."
+				},
+				workScope: {
+					type: "ref",
+					ref: "#workScope"
+				},
+				startDate: {
+					type: "string",
+					format: "datetime",
+					description: "When the work began"
+				},
+				endDate: {
+					type: "string",
+					format: "datetime",
+					description: "When the work ended"
+				},
+				contributions: {
+					type: "array",
+					description: "A strong reference to the contributions done to create the impact in the hypercerts. The record referenced must conform with the lexicon org.hypercerts.claim.contribution.",
+					items: {
+						type: "ref",
+						ref: "com.atproto.repo.strongRef"
+					}
+				},
+				rights: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "A strong reference to the rights that this hypercert has. The record referenced must conform with the lexicon org.hypercerts.claim.rights."
+				},
+				location: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "A strong reference to the location where the activity was performed. The record referenced must conform with the lexicon app.certified.location."
+				},
+				project: {
+					type: "string",
+					format: "at-uri",
+					description: "A reference (AT-URI) to the project record that this activity is part of. The record referenced must conform with the lexicon org.hypercerts.claim.project. This activity must also be referenced by the project, establishing a bidirectional link."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	},
+	workScope: {
+		type: "object",
+		description: "Logical scope of the work using label-based conditions. All labels in `withinAllOf` must apply; at least one label in `withinAnyOf` must apply if provided; no label in `withinNoneOf` may apply.",
+		properties: {
+			withinAllOf: {
+				type: "array",
+				description: "Labels that MUST all hold for the scope to apply.",
+				items: {
+					type: "string"
+				},
+				maxLength: 100
+			},
+			withinAnyOf: {
+				type: "array",
+				description: "Labels of which AT LEAST ONE must hold (optional). If omitted or empty, imposes no additional condition.",
+				items: {
+					type: "string"
+				},
+				maxLength: 100
+			},
+			withinNoneOf: {
+				type: "array",
+				description: "Labels that MUST NOT hold for the scope to apply.",
+				items: {
+					type: "string"
+				},
+				maxLength: 100
+			}
+		}
+	},
+	activityWeight: {
+		type: "object",
+		required: [
+			"activity",
+			"weight"
+		],
+		properties: {
+			activity: {
+				type: "ref",
+				ref: "com.atproto.repo.strongRef",
+				description: "A strong reference to a hypercert activity record. This activity must conform to the lexicon org.hypercerts.claim.activity"
+			},
+			weight: {
+				type: "string",
+				description: "The relative weight/importance of this hypercert activity (stored as a string to avoid float precision issues). Weights can be any positive numeric values and do not need to sum to a specific total; normalization can be performed by the consuming application as needed."
+			}
+		}
+	}
+};
+var ACTIVITY_LEXICON_JSON = {
+	lexicon: lexicon$9,
+	id: id$o,
+	defs: defs$b
+};
+
+var lexicon$8 = 1;
+var id$n = "org.hypercerts.claim.collection";
+var defs$a = {
+	main: {
+		type: "record",
+		description: "A collection/group of hypercerts that have a specific property.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"title",
+				"activities",
+				"createdAt"
+			],
+			properties: {
+				title: {
+					type: "string",
+					description: "The title of this collection",
+					maxLength: 800,
+					maxGraphemes: 80
+				},
+				shortDescription: {
+					type: "string",
+					maxLength: 3000,
+					maxGraphemes: 300,
+					description: "A short description of this collection"
+				},
+				avatar: {
+					type: "blob",
+					description: "Primary avatar image representing this collection across apps and views; typically a square image.",
+					accept: [
+						"image/png",
+						"image/jpeg"
+					],
+					maxSize: 1000000
+				},
+				coverPhoto: {
+					type: "blob",
+					description: "The cover photo of this collection.",
+					accept: [
+						"image/png",
+						"image/jpeg"
+					],
+					maxSize: 1000000
+				},
+				activities: {
+					type: "array",
+					description: "Array of activities with their associated weights in this collection",
+					items: {
+						type: "ref",
+						ref: "org.hypercerts.claim.activity#activityWeight"
+					}
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var COLLECTION_LEXICON_JSON = {
+	lexicon: lexicon$8,
+	id: id$n,
+	defs: defs$a
+};
+
+var lexicon$7 = 1;
+var id$m = "org.hypercerts.claim.contribution";
+var defs$9 = {
+	main: {
+		type: "record",
+		description: "A contribution made toward a hypercert's impact.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"contributors",
+				"createdAt"
+			],
+			properties: {
+				role: {
+					type: "string",
+					description: "Role or title of the contributor(s).",
+					maxLength: 100
+				},
+				contributors: {
+					type: "array",
+					description: "List of the contributors (names, pseudonyms, or DIDs). If multiple contributors are stored in the same hypercertContribution, then they would have the exact same role.",
+					items: {
+						type: "string"
+					}
+				},
+				description: {
+					type: "string",
+					description: "What the contribution concretely achieved",
+					maxLength: 2000,
+					maxGraphemes: 500
+				},
+				startDate: {
+					type: "string",
+					format: "datetime",
+					description: "When this contribution started. This should be a subset of the hypercert timeframe."
+				},
+				endDate: {
+					type: "string",
+					format: "datetime",
+					description: "When this contribution finished.  This should be a subset of the hypercert timeframe."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var CONTRIBUTION_LEXICON_JSON = {
+	lexicon: lexicon$7,
+	id: id$m,
+	defs: defs$9
+};
+
+var lexicon$6 = 1;
+var id$l = "org.hypercerts.claim.evaluation";
+var defs$8 = {
+	score: {
+		type: "object",
+		description: "Overall score for an evaluation on a numeric scale.",
+		required: [
+			"min",
+			"max",
+			"value"
+		],
+		properties: {
+			min: {
+				type: "integer",
+				description: "Minimum value of the scale, e.g. 0 or 1."
+			},
+			max: {
+				type: "integer",
+				description: "Maximum value of the scale, e.g. 5 or 10."
+			},
+			value: {
+				type: "integer",
+				description: "Score within the inclusive range [min, max]."
+			}
+		}
+	},
+	main: {
+		type: "record",
+		description: "An evaluation of a hypercert record (e.g. an activity and its impact).",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"evaluators",
+				"summary",
+				"createdAt"
+			],
+			properties: {
+				subject: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "A strong reference to what is being evaluated. (e.g activity, measurement, contribution, etc.)"
+				},
+				evaluators: {
+					type: "array",
+					description: "DIDs of the evaluators",
+					items: {
+						type: "ref",
+						ref: "app.certified.defs#did"
+					},
+					maxLength: 1000
+				},
+				content: {
+					type: "array",
+					description: "Evaluation data (URIs or blobs) containing detailed reports or methodology",
+					items: {
+						type: "union",
+						refs: [
+							"org.hypercerts.defs#uri",
+							"org.hypercerts.defs#smallBlob"
+						]
+					},
+					maxLength: 100
+				},
+				measurements: {
+					type: "array",
+					description: "Optional references to the measurements that contributed to this evaluation. The record(s) referenced must conform with the lexicon org.hypercerts.claim.measurement ",
+					items: {
+						type: "ref",
+						ref: "com.atproto.repo.strongRef"
+					},
+					maxLength: 100
+				},
+				summary: {
+					type: "string",
+					description: "Brief evaluation summary",
+					maxLength: 5000,
+					maxGraphemes: 1000
+				},
+				score: {
+					type: "ref",
+					ref: "#score",
+					description: "Optional overall score for this evaluation on a numeric scale."
+				},
+				location: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "An optional reference for georeferenced evaluations. The record referenced must conform with the lexicon app.certified.location."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var EVALUATION_LEXICON_JSON = {
+	lexicon: lexicon$6,
+	id: id$l,
+	defs: defs$8
+};
+
+var lexicon$5 = 1;
+var id$k = "org.hypercerts.claim.evidence";
+var defs$7 = {
+	main: {
+		type: "record",
+		description: "A piece of evidence related to a hypercert record (e.g. an activity, project, claim, or evaluation). Evidence may support, clarify, or challenge the referenced subject.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"content",
+				"title",
+				"createdAt"
+			],
+			properties: {
+				subject: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "A strong reference to the record this evidence relates to (e.g. an activity, project, claim, or evaluation)."
+				},
+				content: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallBlob"
+					],
+					description: "A piece of evidence (URI or blob) related to the subject record; it may support, clarify, or challenge a hypercert claim."
+				},
+				title: {
+					type: "string",
+					maxLength: 256,
+					description: "Title to describe the nature of the evidence."
+				},
+				shortDescription: {
+					type: "string",
+					maxLength: 3000,
+					maxGraphemes: 300,
+					description: "Short description explaining what this evidence shows."
+				},
+				description: {
+					type: "string",
+					description: "Longer description describing the evidence in more detail.",
+					maxLength: 30000,
+					maxGraphemes: 3000
+				},
+				relationType: {
+					type: "string",
+					description: "How this evidence relates to the subject.",
+					knownValues: [
+						"supports",
+						"challenges",
+						"clarifies"
+					]
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var EVIDENCE_LEXICON_JSON = {
+	lexicon: lexicon$5,
+	id: id$k,
+	defs: defs$7
+};
+
+var lexicon$4 = 1;
+var id$j = "org.hypercerts.claim.measurement";
+var defs$6 = {
+	main: {
+		type: "record",
+		description: "Measurement data related to a hypercert record (e.g. an activity and its impact).",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"measurers",
+				"metric",
+				"value",
+				"createdAt"
+			],
+			properties: {
+				subject: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "A strong reference to the record this measurement refers to (e.g. an activity, project, or claim)."
+				},
+				measurers: {
+					type: "array",
+					description: "DIDs of the entity (or entities) that measured this data",
+					items: {
+						type: "ref",
+						ref: "app.certified.defs#did"
+					},
+					maxLength: 100
+				},
+				metric: {
+					type: "string",
+					description: "The metric being measured",
+					maxLength: 500
+				},
+				value: {
+					type: "string",
+					description: "The measured value",
+					maxLength: 500
+				},
+				methodType: {
+					type: "string",
+					description: "Short identifier for the measurement methodology",
+					maxLength: 30
+				},
+				methodURI: {
+					type: "string",
+					format: "uri",
+					description: "URI to methodology documentation, standard protocol, or measurement procedure"
+				},
+				evidenceURI: {
+					type: "array",
+					description: "URIs to related evidence or underlying data (e.g. org.hypercerts.claim.evidence records or raw datasets)",
+					items: {
+						type: "string",
+						format: "uri"
+					},
+					maxLength: 50
+				},
+				location: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "A strong reference to the location where the measurement was taken. The record referenced must conform with the lexicon app.certified.location"
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var MEASUREMENT_LEXICON_JSON = {
+	lexicon: lexicon$4,
+	id: id$j,
+	defs: defs$6
+};
+
+var lexicon$3 = 1;
+var id$i = "org.hypercerts.claim.project";
+var defs$5 = {
+	main: {
+		type: "record",
+		description: "A project that can include multiple activities, each of which may be linked to at most one project.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"title",
+				"shortDescription",
+				"createdAt"
+			],
+			properties: {
+				title: {
+					type: "string",
+					description: "Title of this project",
+					maxLength: 800,
+					maxGraphemes: 80
+				},
+				shortDescription: {
+					type: "string",
+					maxLength: 3000,
+					maxGraphemes: 300,
+					description: "Short summary of this project, suitable for previews and list views."
+				},
+				description: {
+					type: "ref",
+					ref: "pub.leaflet.pages.linearDocument#main",
+					description: "Rich-text description of this project, represented as a Leaflet linear document."
+				},
+				avatar: {
+					type: "blob",
+					description: "Primary avatar image representing this project across apps and views; typically a square logo or project identity image.",
+					accept: [
+						"image/png",
+						"image/jpeg"
+					],
+					maxSize: 1000000
+				},
+				coverPhoto: {
+					type: "blob",
+					description: "The cover photo of this project.",
+					accept: [
+						"image/png",
+						"image/jpeg"
+					],
+					maxSize: 1000000
+				},
+				activities: {
+					type: "array",
+					description: "Array of activities with their associated weights in this project",
+					items: {
+						type: "ref",
+						ref: "org.hypercerts.claim.activity#activityWeight"
+					}
+				},
+				location: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "A strong reference to a location record describing where the work for this project took place. The referenced record must conform to the app.certified.location lexicon."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var PROJECT_LEXICON_JSON = {
+	lexicon: lexicon$3,
+	id: id$i,
+	defs: defs$5
 };
 
-var defs = /*#__PURE__*/Object.freeze({
-  __proto__: null
+var lexicon$2 = 1;
+var id$h = "org.hypercerts.claim.rights";
+var defs$4 = {
+	main: {
+		type: "record",
+		description: "Describes the rights that a contributor and/or an owner has, such as whether the hypercert can be sold, transferred, and under what conditions.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"rightsName",
+				"rightsType",
+				"rightsDescription",
+				"createdAt"
+			],
+			properties: {
+				rightsName: {
+					type: "string",
+					description: "Full name of the rights",
+					maxLength: 100
+				},
+				rightsType: {
+					type: "string",
+					description: "Short rights identifier for easier search",
+					maxLength: 10
+				},
+				rightsDescription: {
+					type: "string",
+					description: "Description of the rights of this hypercert"
+				},
+				attachment: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallBlob"
+					],
+					description: "An attachment to define the rights further, e.g. a legal document."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
+				}
+			}
+		}
+	}
+};
+var RIGHTS_LEXICON_JSON = {
+	lexicon: lexicon$2,
+	id: id$h,
+	defs: defs$4
+};
+
+var lexicon$1 = 1;
+var id$g = "org.hypercerts.defs";
+var defs$3 = {
+	uri: {
+		type: "object",
+		required: [
+			"uri"
+		],
+		description: "Object containing a URI to external data",
+		properties: {
+			uri: {
+				type: "string",
+				format: "uri",
+				maxGraphemes: 1024,
+				description: "URI to external data"
+			}
+		}
+	},
+	smallBlob: {
+		type: "object",
+		required: [
+			"blob"
+		],
+		description: "Object containing a blob to external data",
+		properties: {
+			blob: {
+				type: "blob",
+				accept: [
+					"*/*"
+				],
+				maxSize: 10485760,
+				description: "Blob to external data (up to 10MB)"
+			}
+		}
+	},
+	largeBlob: {
+		type: "object",
+		required: [
+			"blob"
+		],
+		description: "Object containing a blob to external data",
+		properties: {
+			blob: {
+				type: "blob",
+				accept: [
+					"*/*"
+				],
+				maxSize: 104857600,
+				description: "Blob to external data (up to 100MB)"
+			}
+		}
+	},
+	smallImage: {
+		type: "object",
+		required: [
+			"image"
+		],
+		description: "Object containing a small image",
+		properties: {
+			image: {
+				type: "blob",
+				accept: [
+					"image/jpeg",
+					"image/jpg",
+					"image/png",
+					"image/webp"
+				],
+				maxSize: 5242880,
+				description: "Image (up to 5MB)"
+			}
+		}
+	},
+	largeImage: {
+		type: "object",
+		required: [
+			"image"
+		],
+		description: "Object containing a large image",
+		properties: {
+			image: {
+				type: "blob",
+				accept: [
+					"image/jpeg",
+					"image/jpg",
+					"image/png",
+					"image/webp"
+				],
+				maxSize: 10485760,
+				description: "Image (up to 10MB)"
+			}
+		}
+	}
+};
+var HYPERCERTS_DEFS_LEXICON_JSON = {
+	lexicon: lexicon$1,
+	id: id$g,
+	defs: defs$3
+};
+
+var lexicon = 1;
+var id$f = "org.hypercerts.funding.receipt";
+var defs$2 = {
+	main: {
+		type: "record",
+		description: "Records a funding receipt for a payment from one user to another user. It may be recorded by the recipient, by the sender, or by a third party. The sender may remain anonymous.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"from",
+				"to",
+				"amount",
+				"currency",
+				"createdAt"
+			],
+			properties: {
+				from: {
+					type: "ref",
+					ref: "app.certified.defs#did",
+					description: "DID of the sender who transferred the funds. Leave empty if sender wants to stay anonymous."
+				},
+				to: {
+					type: "string",
+					description: "The recipient of the funds. Can be identified by DID or a clear-text name."
+				},
+				amount: {
+					type: "string",
+					description: "Amount of funding received."
+				},
+				currency: {
+					type: "string",
+					description: "Currency of the payment (e.g. EUR, USD, ETH)."
+				},
+				paymentRail: {
+					type: "string",
+					description: "How the funds were transferred (e.g. bank_transfer, credit_card, onchain, cash, check, payment_processor)."
+				},
+				paymentNetwork: {
+					type: "string",
+					description: "Optional network within the payment rail (e.g. arbitrum, ethereum, sepa, visa, paypal)."
+				},
+				transactionId: {
+					type: "string",
+					description: "Identifier of the underlying payment transaction (e.g. bank reference, onchain transaction hash, or processor-specific ID). Use paymentNetwork to specify the network where applicable."
+				},
+				"for": {
+					type: "string",
+					format: "at-uri",
+					description: "Optional reference to the activity, project, or organization this funding relates to."
+				},
+				notes: {
+					type: "string",
+					description: "Optional notes or additional context for this funding receipt.",
+					maxLength: 500
+				},
+				occurredAt: {
+					type: "string",
+					format: "datetime",
+					description: "Timestamp when the payment occurred."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this receipt record was created."
+				}
+			}
+		}
+	}
+};
+var FUNDING_RECEIPT_LEXICON_JSON = {
+	lexicon: lexicon,
+	id: id$f,
+	defs: defs$2
+};
+
+const is$typed$e = is$typed$f, validate$e = validate$f;
+const id$e = 'app.certified.badge.award';
+const hashMain$d = 'main';
+function isMain$d(v) {
+    return is$typed$e(v, id$e, hashMain$d);
+}
+function validateMain$d(v) {
+    return validate$e(v, id$e, hashMain$d, true);
+}
+
+var award = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$d,
+    isRecord: isMain$d,
+    validateMain: validateMain$d,
+    validateRecord: validateMain$d
+});
+
+const is$typed$d = is$typed$f, validate$d = validate$f;
+const id$d = 'app.certified.badge.definition';
+const hashMain$c = 'main';
+function isMain$c(v) {
+    return is$typed$d(v, id$d, hashMain$c);
+}
+function validateMain$c(v) {
+    return validate$d(v, id$d, hashMain$c, true);
+}
+
+var definition = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$c,
+    isRecord: isMain$c,
+    validateMain: validateMain$c,
+    validateRecord: validateMain$c
+});
+
+const is$typed$c = is$typed$f, validate$c = validate$f;
+const id$c = 'app.certified.badge.response';
+const hashMain$b = 'main';
+function isMain$b(v) {
+    return is$typed$c(v, id$c, hashMain$b);
+}
+function validateMain$b(v) {
+    return validate$c(v, id$c, hashMain$b, true);
+}
+
+var response = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$b,
+    isRecord: isMain$b,
+    validateMain: validateMain$b,
+    validateRecord: validateMain$b
+});
+
+var defs$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
+const is$typed$b = is$typed$f, validate$b = validate$f;
+const id$b = 'app.certified.location';
+const hashMain$a = 'main';
+function isMain$a(v) {
+    return is$typed$b(v, id$b, hashMain$a);
+}
+function validateMain$a(v) {
+    return validate$b(v, id$b, hashMain$a, true);
+}
+
+var location = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$a,
+    isRecord: isMain$a,
+    validateMain: validateMain$a,
+    validateRecord: validateMain$a
+});
+
+const is$typed$a = is$typed$f, validate$a = validate$f;
+const id$a = 'com.atproto.repo.strongRef';
+const hashMain$9 = 'main';
+function isMain$9(v) {
+    return is$typed$a(v, id$a, hashMain$9);
+}
+function validateMain$9(v) {
+    return validate$a(v, id$a, hashMain$9);
+}
+
+var strongRef = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$9,
+    validateMain: validateMain$9
 });
 
-const is$typed$8 = is$typed$9, validate$8 = validate$9;
-const id$8 = 'app.certified.location';
+const is$typed$9 = is$typed$f, validate$9 = validate$f;
+const id$9 = 'org.hypercerts.claim.activity';
 const hashMain$8 = 'main';
 function isMain$8(v) {
-    return is$typed$8(v, id$8, hashMain$8);
+    return is$typed$9(v, id$9, hashMain$8);
 }
 function validateMain$8(v) {
-    return validate$8(v, id$8, hashMain$8, true);
+    return validate$9(v, id$9, hashMain$8, true);
+}
+const hashWorkScope = 'workScope';
+function isWorkScope(v) {
+    return is$typed$9(v, id$9, hashWorkScope);
+}
+function validateWorkScope(v) {
+    return validate$9(v, id$9, hashWorkScope);
+}
+const hashActivityWeight = 'activityWeight';
+function isActivityWeight(v) {
+    return is$typed$9(v, id$9, hashActivityWeight);
+}
+function validateActivityWeight(v) {
+    return validate$9(v, id$9, hashActivityWeight);
 }
 
-var location = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$8,
-  isRecord: isMain$8,
-  validateMain: validateMain$8,
-  validateRecord: validateMain$8
+var activity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isActivityWeight: isActivityWeight,
+    isMain: isMain$8,
+    isRecord: isMain$8,
+    isWorkScope: isWorkScope,
+    validateActivityWeight: validateActivityWeight,
+    validateMain: validateMain$8,
+    validateRecord: validateMain$8,
+    validateWorkScope: validateWorkScope
 });
 
-const is$typed$7 = is$typed$9, validate$7 = validate$9;
-const id$7 = 'com.atproto.repo.strongRef';
+const is$typed$8 = is$typed$f, validate$8 = validate$f;
+const id$8 = 'org.hypercerts.claim.collection';
 const hashMain$7 = 'main';
 function isMain$7(v) {
-    return is$typed$7(v, id$7, hashMain$7);
+    return is$typed$8(v, id$8, hashMain$7);
 }
 function validateMain$7(v) {
-    return validate$7(v, id$7, hashMain$7);
+    return validate$8(v, id$8, hashMain$7, true);
 }
 
-var strongRef = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$7,
-  validateMain: validateMain$7
+var collection = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$7,
+    isRecord: isMain$7,
+    validateMain: validateMain$7,
+    validateRecord: validateMain$7
 });
 
-const is$typed$6 = is$typed$9, validate$6 = validate$9;
-const id$6 = 'org.hypercerts.claim';
+const is$typed$7 = is$typed$f, validate$7 = validate$f;
+const id$7 = 'org.hypercerts.claim.contribution';
 const hashMain$6 = 'main';
 function isMain$6(v) {
-    return is$typed$6(v, id$6, hashMain$6);
+    return is$typed$7(v, id$7, hashMain$6);
 }
 function validateMain$6(v) {
-    return validate$6(v, id$6, hashMain$6, true);
+    return validate$7(v, id$7, hashMain$6, true);
 }
 
-var claim = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$6,
-  isRecord: isMain$6,
-  validateMain: validateMain$6,
-  validateRecord: validateMain$6
+var contribution = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$6,
+    isRecord: isMain$6,
+    validateMain: validateMain$6,
+    validateRecord: validateMain$6
 });
 
-const is$typed$5 = is$typed$9, validate$5 = validate$9;
-const id$5 = 'org.hypercerts.claim.contribution';
+const is$typed$6 = is$typed$f, validate$6 = validate$f;
+const id$6 = 'org.hypercerts.claim.evaluation';
+const hashScore = 'score';
+function isScore(v) {
+    return is$typed$6(v, id$6, hashScore);
+}
+function validateScore(v) {
+    return validate$6(v, id$6, hashScore);
+}
 const hashMain$5 = 'main';
 function isMain$5(v) {
-    return is$typed$5(v, id$5, hashMain$5);
+    return is$typed$6(v, id$6, hashMain$5);
 }
 function validateMain$5(v) {
-    return validate$5(v, id$5, hashMain$5, true);
+    return validate$6(v, id$6, hashMain$5, true);
 }
 
-var contribution = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$5,
-  isRecord: isMain$5,
-  validateMain: validateMain$5,
-  validateRecord: validateMain$5
+var evaluation = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$5,
+    isRecord: isMain$5,
+    isScore: isScore,
+    validateMain: validateMain$5,
+    validateRecord: validateMain$5,
+    validateScore: validateScore
 });
 
-const is$typed$4 = is$typed$9, validate$4 = validate$9;
-const id$4 = 'org.hypercerts.claim.evaluation';
+const is$typed$5 = is$typed$f, validate$5 = validate$f;
+const id$5 = 'org.hypercerts.claim.evidence';
 const hashMain$4 = 'main';
 function isMain$4(v) {
-    return is$typed$4(v, id$4, hashMain$4);
+    return is$typed$5(v, id$5, hashMain$4);
 }
 function validateMain$4(v) {
-    return validate$4(v, id$4, hashMain$4, true);
+    return validate$5(v, id$5, hashMain$4, true);
 }
 
-var evaluation = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$4,
-  isRecord: isMain$4,
-  validateMain: validateMain$4,
-  validateRecord: validateMain$4
+var evidence = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$4,
+    isRecord: isMain$4,
+    validateMain: validateMain$4,
+    validateRecord: validateMain$4
 });
 
-const is$typed$3 = is$typed$9, validate$3 = validate$9;
-const id$3 = 'org.hypercerts.claim.evidence';
+const is$typed$4 = is$typed$f, validate$4 = validate$f;
+const id$4 = 'org.hypercerts.claim.measurement';
 const hashMain$3 = 'main';
 function isMain$3(v) {
-    return is$typed$3(v, id$3, hashMain$3);
+    return is$typed$4(v, id$4, hashMain$3);
 }
 function validateMain$3(v) {
-    return validate$3(v, id$3, hashMain$3, true);
+    return validate$4(v, id$4, hashMain$3, true);
 }
 
-var evidence = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$3,
-  isRecord: isMain$3,
-  validateMain: validateMain$3,
-  validateRecord: validateMain$3
+var measurement = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$3,
+    isRecord: isMain$3,
+    validateMain: validateMain$3,
+    validateRecord: validateMain$3
 });
 
-const is$typed$2 = is$typed$9, validate$2 = validate$9;
-const id$2 = 'org.hypercerts.claim.measurement';
+const is$typed$3 = is$typed$f, validate$3 = validate$f;
+const id$3 = 'org.hypercerts.claim.project';
 const hashMain$2 = 'main';
 function isMain$2(v) {
-    return is$typed$2(v, id$2, hashMain$2);
+    return is$typed$3(v, id$3, hashMain$2);
 }
 function validateMain$2(v) {
-    return validate$2(v, id$2, hashMain$2, true);
+    return validate$3(v, id$3, hashMain$2, true);
 }
 
-var measurement = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$2,
-  isRecord: isMain$2,
-  validateMain: validateMain$2,
-  validateRecord: validateMain$2
+var project = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$2,
+    isRecord: isMain$2,
+    validateMain: validateMain$2,
+    validateRecord: validateMain$2
 });
 
-const is$typed$1 = is$typed$9, validate$1 = validate$9;
-const id$1 = 'org.hypercerts.claim.rights';
+const is$typed$2 = is$typed$f, validate$2 = validate$f;
+const id$2 = 'org.hypercerts.claim.rights';
 const hashMain$1 = 'main';
 function isMain$1(v) {
-    return is$typed$1(v, id$1, hashMain$1);
+    return is$typed$2(v, id$2, hashMain$1);
 }
 function validateMain$1(v) {
-    return validate$1(v, id$1, hashMain$1, true);
+    return validate$2(v, id$2, hashMain$1, true);
 }
 
 var rights = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$1,
-  isRecord: isMain$1,
-  validateMain: validateMain$1,
-  validateRecord: validateMain$1
+    __proto__: null,
+    isMain: isMain$1,
+    isRecord: isMain$1,
+    validateMain: validateMain$1,
+    validateRecord: validateMain$1
+});
+
+const is$typed$1 = is$typed$f, validate$1 = validate$f;
+const id$1 = 'org.hypercerts.defs';
+const hashUri = 'uri';
+function isUri(v) {
+    return is$typed$1(v, id$1, hashUri);
+}
+function validateUri(v) {
+    return validate$1(v, id$1, hashUri);
+}
+const hashSmallBlob = 'smallBlob';
+function isSmallBlob(v) {
+    return is$typed$1(v, id$1, hashSmallBlob);
+}
+function validateSmallBlob(v) {
+    return validate$1(v, id$1, hashSmallBlob);
+}
+const hashLargeBlob = 'largeBlob';
+function isLargeBlob(v) {
+    return is$typed$1(v, id$1, hashLargeBlob);
+}
+function validateLargeBlob(v) {
+    return validate$1(v, id$1, hashLargeBlob);
+}
+const hashSmallImage = 'smallImage';
+function isSmallImage(v) {
+    return is$typed$1(v, id$1, hashSmallImage);
+}
+function validateSmallImage(v) {
+    return validate$1(v, id$1, hashSmallImage);
+}
+const hashLargeImage = 'largeImage';
+function isLargeImage(v) {
+    return is$typed$1(v, id$1, hashLargeImage);
+}
+function validateLargeImage(v) {
+    return validate$1(v, id$1, hashLargeImage);
+}
+
+var defs = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isLargeBlob: isLargeBlob,
+    isLargeImage: isLargeImage,
+    isSmallBlob: isSmallBlob,
+    isSmallImage: isSmallImage,
+    isUri: isUri,
+    validateLargeBlob: validateLargeBlob,
+    validateLargeImage: validateLargeImage,
+    validateSmallBlob: validateSmallBlob,
+    validateSmallImage: validateSmallImage,
+    validateUri: validateUri
 });
 
-const is$typed = is$typed$9, validate = validate$9;
-const id = 'org.hypercerts.collection';
+const is$typed = is$typed$f, validate = validate$f;
+const id = 'org.hypercerts.funding.receipt';
 const hashMain = 'main';
 function isMain(v) {
     return is$typed(v, id, hashMain);
@@ -1353,25 +2424,30 @@ function isMain(v) {
 function validateMain(v) {
     return validate(v, id, hashMain, true);
 }
-const hashClaimItem = 'claimItem';
-function isClaimItem(v) {
-    return is$typed(v, id, hashClaimItem);
-}
-function validateClaimItem(v) {
-    return validate(v, id, hashClaimItem);
-}
 
-var collection = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isClaimItem: isClaimItem,
-  isMain: isMain,
-  isRecord: isMain,
-  validateClaimItem: validateClaimItem,
-  validateMain: validateMain,
-  validateRecord: validateMain
+var receipt = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain,
+    isRecord: isMain,
+    validateMain: validateMain,
+    validateRecord: validateMain
 });
 
 /**
+ * @file Auto-generated exports for hypercert lexicons
+ *
+ * ⚠️  DO NOT EDIT THIS FILE MANUALLY ⚠️
+ *
+ * This file is automatically generated by scripts/generate-exports.js
+ * Generated: 2026-01-02T20:37:58.264Z
+ *
+ * To regenerate this file, run:
+ *   npm run gen-api
+ * or:
+ *   npm run gen-index
+ *
+ * ---
+ *
  * Hypercert lexicon definitions for AT Protocol.
  *
  * This module exports the lexicon documents, collection names,
@@ -1379,63 +2455,106 @@ var collection = /*#__PURE__*/Object.freeze({
  *
  * @packageDocumentation
  */
+// Individual NSID constants
+const BADGE_AWARD_NSID = "app.certified.badge.award";
+const BADGE_DEFINITION_NSID = "app.certified.badge.definition";
+const BADGE_RESPONSE_NSID = "app.certified.badge.response";
+const CERTIFIED_DEFS_NSID = "app.certified.defs";
+const LOCATION_NSID = "app.certified.location";
+const STRONGREF_NSID = "com.atproto.repo.strongRef";
+const ACTIVITY_NSID = "org.hypercerts.claim.activity";
+const COLLECTION_NSID = "org.hypercerts.claim.collection";
+const CONTRIBUTION_NSID = "org.hypercerts.claim.contribution";
+const EVALUATION_NSID = "org.hypercerts.claim.evaluation";
+const EVIDENCE_NSID = "org.hypercerts.claim.evidence";
+const MEASUREMENT_NSID = "org.hypercerts.claim.measurement";
+const PROJECT_NSID = "org.hypercerts.claim.project";
+const RIGHTS_NSID = "org.hypercerts.claim.rights";
+const HYPERCERTS_DEFS_NSID = "org.hypercerts.defs";
+const FUNDING_RECEIPT_NSID = "org.hypercerts.funding.receipt";
 /**
- * All hypercert-related lexicons for registration with AT Protocol Agent.
- *
- * This array contains all lexicon documents needed to work with
- * hypercert records.
- */
-const HYPERCERT_LEXICONS = [
-    defsLexicon,
-    locationLexicon,
-    claimLexicon,
-    rightsLexicon,
-    contributionLexicon,
-    measurementLexicon,
-    evaluationLexicon,
-    evidenceLexicon,
-    collectionLexicon,
-];
-/**
- * Collection NSIDs (Namespaced Identifiers) for hypercert records.
+ * Collection NSIDs organized by semantic record type.
  *
  * Use these constants when performing record operations to ensure
  * correct collection names.
  */
-const HYPERCERT_COLLECTIONS = {
-    /**
-     * Main hypercert claim record collection.
-     */
-    CLAIM: "org.hypercerts.claim",
-    /**
-     * Rights record collection.
-     */
-    RIGHTS: "org.hypercerts.claim.rights",
-    /**
-     * Location record collection (shared certified lexicon).
-     */
-    LOCATION: "app.certified.location",
-    /**
-     * Contribution record collection.
-     */
-    CONTRIBUTION: "org.hypercerts.claim.contribution",
-    /**
-     * Measurement record collection.
-     */
-    MEASUREMENT: "org.hypercerts.claim.measurement",
-    /**
-     * Evaluation record collection.
-     */
-    EVALUATION: "org.hypercerts.claim.evaluation",
-    /**
-     * Evidence record collection.
-     */
-    EVIDENCE: "org.hypercerts.claim.evidence",
-    /**
-     * Collection record collection (groups of hypercerts).
-     */
-    COLLECTION: "org.hypercerts.collection",
+const HYPERCERTS_NSIDS = {
+    BADGE_AWARD: BADGE_AWARD_NSID,
+    BADGE_DEFINITION: BADGE_DEFINITION_NSID,
+    BADGE_RESPONSE: BADGE_RESPONSE_NSID,
+    CERTIFIED_DEFS: CERTIFIED_DEFS_NSID,
+    LOCATION: LOCATION_NSID,
+    STRONGREF: STRONGREF_NSID,
+    ACTIVITY: ACTIVITY_NSID,
+    COLLECTION: COLLECTION_NSID,
+    CONTRIBUTION: CONTRIBUTION_NSID,
+    EVALUATION: EVALUATION_NSID,
+    EVIDENCE: EVIDENCE_NSID,
+    MEASUREMENT: MEASUREMENT_NSID,
+    PROJECT: PROJECT_NSID,
+    RIGHTS: RIGHTS_NSID,
+    HYPERCERTS_DEFS: HYPERCERTS_DEFS_NSID,
+    FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,
+};
+/**
+ * Lexicon JSON objects organized by semantic record type.
+ */
+const HYPERCERTS_LEXICON_JSON = {
+    BADGE_AWARD: BADGE_AWARD_LEXICON_JSON,
+    BADGE_DEFINITION: BADGE_DEFINITION_LEXICON_JSON,
+    BADGE_RESPONSE: BADGE_RESPONSE_LEXICON_JSON,
+    CERTIFIED_DEFS: CERTIFIED_DEFS_LEXICON_JSON,
+    LOCATION: LOCATION_LEXICON_JSON,
+    STRONGREF: STRONGREF_LEXICON_JSON,
+    ACTIVITY: ACTIVITY_LEXICON_JSON,
+    COLLECTION: COLLECTION_LEXICON_JSON,
+    CONTRIBUTION: CONTRIBUTION_LEXICON_JSON,
+    EVALUATION: EVALUATION_LEXICON_JSON,
+    EVIDENCE: EVIDENCE_LEXICON_JSON,
+    MEASUREMENT: MEASUREMENT_LEXICON_JSON,
+    PROJECT: PROJECT_LEXICON_JSON,
+    RIGHTS: RIGHTS_LEXICON_JSON,
+    HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_JSON,
+    FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_JSON,
+};
+// Individual lexicon objects (from lexicons.get())
+const BADGE_AWARD_LEXICON_DOC = lexicons.get(BADGE_AWARD_NSID);
+const BADGE_DEFINITION_LEXICON_DOC = lexicons.get(BADGE_DEFINITION_NSID);
+const BADGE_RESPONSE_LEXICON_DOC = lexicons.get(BADGE_RESPONSE_NSID);
+const CERTIFIED_DEFS_LEXICON_DOC = lexicons.get(CERTIFIED_DEFS_NSID);
+const LOCATION_LEXICON_DOC = lexicons.get(LOCATION_NSID);
+const STRONGREF_LEXICON_DOC = lexicons.get(STRONGREF_NSID);
+const ACTIVITY_LEXICON_DOC = lexicons.get(ACTIVITY_NSID);
+const COLLECTION_LEXICON_DOC = lexicons.get(COLLECTION_NSID);
+const CONTRIBUTION_LEXICON_DOC = lexicons.get(CONTRIBUTION_NSID);
+const EVALUATION_LEXICON_DOC = lexicons.get(EVALUATION_NSID);
+const EVIDENCE_LEXICON_DOC = lexicons.get(EVIDENCE_NSID);
+const MEASUREMENT_LEXICON_DOC = lexicons.get(MEASUREMENT_NSID);
+const PROJECT_LEXICON_DOC = lexicons.get(PROJECT_NSID);
+const RIGHTS_LEXICON_DOC = lexicons.get(RIGHTS_NSID);
+const HYPERCERTS_DEFS_LEXICON_DOC = lexicons.get(HYPERCERTS_DEFS_NSID);
+const FUNDING_RECEIPT_LEXICON_DOC = lexicons.get(FUNDING_RECEIPT_NSID);
+/**
+ * Lexicon document objects organized by semantic record type.
+ */
+const HYPERCERTS_LEXICON_DOC = {
+    BADGE_AWARD: BADGE_AWARD_LEXICON_DOC,
+    BADGE_DEFINITION: BADGE_DEFINITION_LEXICON_DOC,
+    BADGE_RESPONSE: BADGE_RESPONSE_LEXICON_DOC,
+    CERTIFIED_DEFS: CERTIFIED_DEFS_LEXICON_DOC,
+    LOCATION: LOCATION_LEXICON_DOC,
+    STRONGREF: STRONGREF_LEXICON_DOC,
+    ACTIVITY: ACTIVITY_LEXICON_DOC,
+    COLLECTION: COLLECTION_LEXICON_DOC,
+    CONTRIBUTION: CONTRIBUTION_LEXICON_DOC,
+    EVALUATION: EVALUATION_LEXICON_DOC,
+    EVIDENCE: EVIDENCE_LEXICON_DOC,
+    MEASUREMENT: MEASUREMENT_LEXICON_DOC,
+    PROJECT: PROJECT_LEXICON_DOC,
+    RIGHTS: RIGHTS_LEXICON_DOC,
+    HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_DOC,
+    FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_DOC,
 };
 
-export { defs as AppCertifiedDefs, location as AppCertifiedLocation, strongRef as ComAtprotoRepoStrongRef, HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS, claim as OrgHypercertsClaim, contribution as OrgHypercertsClaimContribution, evaluation as OrgHypercertsClaimEvaluation, evidence as OrgHypercertsClaimEvidence, measurement as OrgHypercertsClaimMeasurement, rights as OrgHypercertsClaimRights, collection as OrgHypercertsCollection, asPredicate, claimLexicon, collectionLexicon, contributionLexicon, defsLexicon, evaluationLexicon, evidenceLexicon, ids, is$typed$9 as is$typed, lexicons, locationLexicon, maybe$typed, measurementLexicon, rightsLexicon, schemaDict, schemas, strongRef$1 as strongRefLexicon, validate$9 as validate };
+export { ACTIVITY_LEXICON_DOC, ACTIVITY_LEXICON_JSON, ACTIVITY_NSID, award as AppCertifiedBadgeAward, definition as AppCertifiedBadgeDefinition, response as AppCertifiedBadgeResponse, defs$1 as AppCertifiedDefs, location as AppCertifiedLocation, BADGE_AWARD_LEXICON_DOC, BADGE_AWARD_LEXICON_JSON, BADGE_AWARD_NSID, BADGE_DEFINITION_LEXICON_DOC, BADGE_DEFINITION_LEXICON_JSON, BADGE_DEFINITION_NSID, BADGE_RESPONSE_LEXICON_DOC, BADGE_RESPONSE_LEXICON_JSON, BADGE_RESPONSE_NSID, CERTIFIED_DEFS_LEXICON_DOC, CERTIFIED_DEFS_LEXICON_JSON, CERTIFIED_DEFS_NSID, COLLECTION_LEXICON_DOC, COLLECTION_LEXICON_JSON, COLLECTION_NSID, CONTRIBUTION_LEXICON_DOC, CONTRIBUTION_LEXICON_JSON, CONTRIBUTION_NSID, strongRef as ComAtprotoRepoStrongRef, EVALUATION_LEXICON_DOC, EVALUATION_LEXICON_JSON, EVALUATION_NSID, EVIDENCE_LEXICON_DOC, EVIDENCE_LEXICON_JSON, EVIDENCE_NSID, FUNDING_RECEIPT_LEXICON_DOC, FUNDING_RECEIPT_LEXICON_JSON, FUNDING_RECEIPT_NSID, HYPERCERTS_DEFS_LEXICON_DOC, HYPERCERTS_DEFS_LEXICON_JSON, HYPERCERTS_DEFS_NSID, HYPERCERTS_LEXICON_DOC, HYPERCERTS_LEXICON_JSON, HYPERCERTS_NSIDS, ids as HYPERCERTS_NSIDS_BY_TYPE, schemas as HYPERCERTS_SCHEMAS, schemaDict as HYPERCERTS_SCHEMA_DICT, LOCATION_LEXICON_DOC, LOCATION_LEXICON_JSON, LOCATION_NSID, MEASUREMENT_LEXICON_DOC, MEASUREMENT_LEXICON_JSON, MEASUREMENT_NSID, activity as OrgHypercertsClaimActivity, collection as OrgHypercertsClaimCollection, contribution as OrgHypercertsClaimContribution, evaluation as OrgHypercertsClaimEvaluation, evidence as OrgHypercertsClaimEvidence, measurement as OrgHypercertsClaimMeasurement, project as OrgHypercertsClaimProject, rights as OrgHypercertsClaimRights, defs as OrgHypercertsDefs, receipt as OrgHypercertsFundingReceipt, PROJECT_LEXICON_DOC, PROJECT_LEXICON_JSON, PROJECT_NSID, RIGHTS_LEXICON_DOC, RIGHTS_LEXICON_JSON, RIGHTS_NSID, STRONGREF_LEXICON_DOC, STRONGREF_LEXICON_JSON, STRONGREF_NSID, asPredicate, is$typed$f as is$typed, lexicons, maybe$typed, validate$f as validate };
 //# sourceMappingURL=index.mjs.map