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

package/dist/index.cjs

@@ -1,672 +1,181 @@
 'use strict';
 
-var lexicon$a = require('@atproto/lexicon');
+var lexicon$g = require('@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.',
             },
         },
     },
@@ -677,7 +186,7 @@ const schemaDict = {
             main: {
                 type: 'record',
                 description: 'A location reference',
-                key: 'any',
+                key: 'tid',
                 record: {
                     type: 'object',
                     required: [
@@ -708,8 +217,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.',
                         },
@@ -756,9 +265,9 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaim: {
+    OrgHypercertsClaimActivity: {
         lexicon: 1,
-        id: 'org.hypercerts.claim',
+        id: 'org.hypercerts.claim.activity',
         defs: {
             main: {
                 type: 'record',
@@ -770,14 +279,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: {
@@ -795,40 +303,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',
@@ -837,12 +333,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',
@@ -861,16 +461,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).',
@@ -889,12 +484,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.',
@@ -913,46 +508,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',
@@ -969,41 +602,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',
                         },
                     },
                 },
@@ -1016,23 +659,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,
                         },
@@ -1046,20 +689,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',
@@ -1076,8 +793,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: [
@@ -1101,6 +818,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',
@@ -1111,243 +836,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 lexicon$a.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 lexicon$a.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 lexicon$g.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 lexicon$g.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);
@@ -1355,25 +2426,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,
@@ -1381,92 +2457,180 @@ 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,
 };
 
-exports.AppCertifiedDefs = defs;
+exports.ACTIVITY_LEXICON_DOC = ACTIVITY_LEXICON_DOC;
+exports.ACTIVITY_LEXICON_JSON = ACTIVITY_LEXICON_JSON;
+exports.ACTIVITY_NSID = ACTIVITY_NSID;
+exports.AppCertifiedBadgeAward = award;
+exports.AppCertifiedBadgeDefinition = definition;
+exports.AppCertifiedBadgeResponse = response;
+exports.AppCertifiedDefs = defs$1;
 exports.AppCertifiedLocation = location;
+exports.BADGE_AWARD_LEXICON_DOC = BADGE_AWARD_LEXICON_DOC;
+exports.BADGE_AWARD_LEXICON_JSON = BADGE_AWARD_LEXICON_JSON;
+exports.BADGE_AWARD_NSID = BADGE_AWARD_NSID;
+exports.BADGE_DEFINITION_LEXICON_DOC = BADGE_DEFINITION_LEXICON_DOC;
+exports.BADGE_DEFINITION_LEXICON_JSON = BADGE_DEFINITION_LEXICON_JSON;
+exports.BADGE_DEFINITION_NSID = BADGE_DEFINITION_NSID;
+exports.BADGE_RESPONSE_LEXICON_DOC = BADGE_RESPONSE_LEXICON_DOC;
+exports.BADGE_RESPONSE_LEXICON_JSON = BADGE_RESPONSE_LEXICON_JSON;
+exports.BADGE_RESPONSE_NSID = BADGE_RESPONSE_NSID;
+exports.CERTIFIED_DEFS_LEXICON_DOC = CERTIFIED_DEFS_LEXICON_DOC;
+exports.CERTIFIED_DEFS_LEXICON_JSON = CERTIFIED_DEFS_LEXICON_JSON;
+exports.CERTIFIED_DEFS_NSID = CERTIFIED_DEFS_NSID;
+exports.COLLECTION_LEXICON_DOC = COLLECTION_LEXICON_DOC;
+exports.COLLECTION_LEXICON_JSON = COLLECTION_LEXICON_JSON;
+exports.COLLECTION_NSID = COLLECTION_NSID;
+exports.CONTRIBUTION_LEXICON_DOC = CONTRIBUTION_LEXICON_DOC;
+exports.CONTRIBUTION_LEXICON_JSON = CONTRIBUTION_LEXICON_JSON;
+exports.CONTRIBUTION_NSID = CONTRIBUTION_NSID;
 exports.ComAtprotoRepoStrongRef = strongRef;
-exports.HYPERCERT_COLLECTIONS = HYPERCERT_COLLECTIONS;
-exports.HYPERCERT_LEXICONS = HYPERCERT_LEXICONS;
-exports.OrgHypercertsClaim = claim;
+exports.EVALUATION_LEXICON_DOC = EVALUATION_LEXICON_DOC;
+exports.EVALUATION_LEXICON_JSON = EVALUATION_LEXICON_JSON;
+exports.EVALUATION_NSID = EVALUATION_NSID;
+exports.EVIDENCE_LEXICON_DOC = EVIDENCE_LEXICON_DOC;
+exports.EVIDENCE_LEXICON_JSON = EVIDENCE_LEXICON_JSON;
+exports.EVIDENCE_NSID = EVIDENCE_NSID;
+exports.FUNDING_RECEIPT_LEXICON_DOC = FUNDING_RECEIPT_LEXICON_DOC;
+exports.FUNDING_RECEIPT_LEXICON_JSON = FUNDING_RECEIPT_LEXICON_JSON;
+exports.FUNDING_RECEIPT_NSID = FUNDING_RECEIPT_NSID;
+exports.HYPERCERTS_DEFS_LEXICON_DOC = HYPERCERTS_DEFS_LEXICON_DOC;
+exports.HYPERCERTS_DEFS_LEXICON_JSON = HYPERCERTS_DEFS_LEXICON_JSON;
+exports.HYPERCERTS_DEFS_NSID = HYPERCERTS_DEFS_NSID;
+exports.HYPERCERTS_LEXICON_DOC = HYPERCERTS_LEXICON_DOC;
+exports.HYPERCERTS_LEXICON_JSON = HYPERCERTS_LEXICON_JSON;
+exports.HYPERCERTS_NSIDS = HYPERCERTS_NSIDS;
+exports.HYPERCERTS_NSIDS_BY_TYPE = ids;
+exports.HYPERCERTS_SCHEMAS = schemas;
+exports.HYPERCERTS_SCHEMA_DICT = schemaDict;
+exports.LOCATION_LEXICON_DOC = LOCATION_LEXICON_DOC;
+exports.LOCATION_LEXICON_JSON = LOCATION_LEXICON_JSON;
+exports.LOCATION_NSID = LOCATION_NSID;
+exports.MEASUREMENT_LEXICON_DOC = MEASUREMENT_LEXICON_DOC;
+exports.MEASUREMENT_LEXICON_JSON = MEASUREMENT_LEXICON_JSON;
+exports.MEASUREMENT_NSID = MEASUREMENT_NSID;
+exports.OrgHypercertsClaimActivity = activity;
+exports.OrgHypercertsClaimCollection = collection;
 exports.OrgHypercertsClaimContribution = contribution;
 exports.OrgHypercertsClaimEvaluation = evaluation;
 exports.OrgHypercertsClaimEvidence = evidence;
 exports.OrgHypercertsClaimMeasurement = measurement;
+exports.OrgHypercertsClaimProject = project;
 exports.OrgHypercertsClaimRights = rights;
-exports.OrgHypercertsCollection = collection;
+exports.OrgHypercertsDefs = defs;
+exports.OrgHypercertsFundingReceipt = receipt;
+exports.PROJECT_LEXICON_DOC = PROJECT_LEXICON_DOC;
+exports.PROJECT_LEXICON_JSON = PROJECT_LEXICON_JSON;
+exports.PROJECT_NSID = PROJECT_NSID;
+exports.RIGHTS_LEXICON_DOC = RIGHTS_LEXICON_DOC;
+exports.RIGHTS_LEXICON_JSON = RIGHTS_LEXICON_JSON;
+exports.RIGHTS_NSID = RIGHTS_NSID;
+exports.STRONGREF_LEXICON_DOC = STRONGREF_LEXICON_DOC;
+exports.STRONGREF_LEXICON_JSON = STRONGREF_LEXICON_JSON;
+exports.STRONGREF_NSID = STRONGREF_NSID;
 exports.asPredicate = asPredicate;
-exports.claimLexicon = claimLexicon;
-exports.collectionLexicon = collectionLexicon;
-exports.contributionLexicon = contributionLexicon;
-exports.defsLexicon = defsLexicon;
-exports.evaluationLexicon = evaluationLexicon;
-exports.evidenceLexicon = evidenceLexicon;
-exports.ids = ids;
-exports.is$typed = is$typed$9;
+exports.is$typed = is$typed$f;
 exports.lexicons = lexicons;
-exports.locationLexicon = locationLexicon;
 exports.maybe$typed = maybe$typed;
-exports.measurementLexicon = measurementLexicon;
-exports.rightsLexicon = rightsLexicon;
-exports.schemaDict = schemaDict;
-exports.schemas = schemas;
-exports.strongRefLexicon = strongRef$1;
-exports.validate = validate$9;
+exports.validate = validate$f;
 //# sourceMappingURL=index.cjs.map