@hypercerts-org/lexicon 0.8.0-beta.0 → 0.10.0-beta.0

package/dist/index.cjs

@@ -1,1472 +0,0 @@
-'use strict';
-
-var lexicon$a = 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
- */
-const schemaDict = {
-    AppCertifiedDefs: {
-        lexicon: 1,
-        id: 'app.certified.defs',
-        defs: {
-            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)',
-            },
-        },
-    },
-    AppCertifiedLocation: {
-        lexicon: 1,
-        id: 'app.certified.location',
-        defs: {
-            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: [
-                                'lex:app.certified.defs#uri',
-                                'lex: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',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    ComAtprotoRepoStrongRef: {
-        lexicon: 1,
-        id: 'com.atproto.repo.strongRef',
-        description: 'A URI with a content-hash fingerprint.',
-        defs: {
-            main: {
-                type: 'object',
-                required: ['uri', 'cid'],
-                properties: {
-                    uri: {
-                        type: 'string',
-                        format: 'at-uri',
-                    },
-                    cid: {
-                        type: 'string',
-                        format: 'cid',
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsClaim: {
-        lexicon: 1,
-        id: 'org.hypercerts.claim',
-        defs: {
-            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: [
-                                'lex:app.certified.defs#uri',
-                                'lex: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: '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',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:com.atproto.repo.strongRef',
-                            },
-                        },
-                        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',
-                        },
-                        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',
-                        },
-                        createdAt: {
-                            type: 'string',
-                            format: 'datetime',
-                            description: 'Client-declared timestamp when this record was originally created',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsClaimContribution: {
-        lexicon: 1,
-        id: 'org.hypercerts.claim.contribution',
-        defs: {
-            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: '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).',
-                            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',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsClaimEvaluation: {
-        lexicon: 1,
-        id: 'org.hypercerts.claim.evaluation',
-        defs: {
-            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: 'lex: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: [
-                                    'lex:app.certified.defs#uri',
-                                    'lex: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',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsClaimEvidence: {
-        lexicon: 1,
-        id: 'org.hypercerts.claim.evidence',
-        defs: {
-            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: [
-                                'lex:app.certified.defs#uri',
-                                'lex: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',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsClaimMeasurement: {
-        lexicon: 1,
-        id: 'org.hypercerts.claim.measurement',
-        defs: {
-            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: '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.',
-                        },
-                        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',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsClaimRights: {
-        lexicon: 1,
-        id: 'org.hypercerts.claim.rights',
-        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',
-                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',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsCollection: {
-        lexicon: 1,
-        id: 'org.hypercerts.collection',
-        defs: {
-            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: [
-                                '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).',
-                        },
-                        claims: {
-                            type: 'array',
-                            description: 'Array of claims with their associated weights in this collection',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:org.hypercerts.collection#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: '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',
-};
-
-var defs = /*#__PURE__*/Object.freeze({
-  __proto__: null
-});
-
-const is$typed$8 = is$typed$9, validate$8 = validate$9;
-const id$8 = 'app.certified.location';
-const hashMain$8 = 'main';
-function isMain$8(v) {
-    return is$typed$8(v, id$8, hashMain$8);
-}
-function validateMain$8(v) {
-    return validate$8(v, id$8, hashMain$8, true);
-}
-
-var location = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$8,
-  isRecord: isMain$8,
-  validateMain: validateMain$8,
-  validateRecord: validateMain$8
-});
-
-const is$typed$7 = is$typed$9, validate$7 = validate$9;
-const id$7 = 'com.atproto.repo.strongRef';
-const hashMain$7 = 'main';
-function isMain$7(v) {
-    return is$typed$7(v, id$7, hashMain$7);
-}
-function validateMain$7(v) {
-    return validate$7(v, id$7, hashMain$7);
-}
-
-var strongRef = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$7,
-  validateMain: validateMain$7
-});
-
-const is$typed$6 = is$typed$9, validate$6 = validate$9;
-const id$6 = 'org.hypercerts.claim';
-const hashMain$6 = 'main';
-function isMain$6(v) {
-    return is$typed$6(v, id$6, hashMain$6);
-}
-function validateMain$6(v) {
-    return validate$6(v, id$6, hashMain$6, true);
-}
-
-var claim = /*#__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 hashMain$5 = 'main';
-function isMain$5(v) {
-    return is$typed$5(v, id$5, hashMain$5);
-}
-function validateMain$5(v) {
-    return validate$5(v, id$5, hashMain$5, true);
-}
-
-var contribution = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$5,
-  isRecord: isMain$5,
-  validateMain: validateMain$5,
-  validateRecord: validateMain$5
-});
-
-const is$typed$4 = is$typed$9, validate$4 = validate$9;
-const id$4 = 'org.hypercerts.claim.evaluation';
-const hashMain$4 = 'main';
-function isMain$4(v) {
-    return is$typed$4(v, id$4, hashMain$4);
-}
-function validateMain$4(v) {
-    return validate$4(v, id$4, hashMain$4, true);
-}
-
-var evaluation = /*#__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 hashMain$3 = 'main';
-function isMain$3(v) {
-    return is$typed$3(v, id$3, hashMain$3);
-}
-function validateMain$3(v) {
-    return validate$3(v, id$3, hashMain$3, true);
-}
-
-var evidence = /*#__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 hashMain$2 = 'main';
-function isMain$2(v) {
-    return is$typed$2(v, id$2, hashMain$2);
-}
-function validateMain$2(v) {
-    return validate$2(v, id$2, hashMain$2, true);
-}
-
-var measurement = /*#__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 hashMain$1 = 'main';
-function isMain$1(v) {
-    return is$typed$1(v, id$1, hashMain$1);
-}
-function validateMain$1(v) {
-    return validate$1(v, id$1, hashMain$1, true);
-}
-
-var rights = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  isMain: isMain$1,
-  isRecord: isMain$1,
-  validateMain: validateMain$1,
-  validateRecord: validateMain$1
-});
-
-const is$typed = is$typed$9, validate = validate$9;
-const id = 'org.hypercerts.collection';
-const hashMain = 'main';
-function isMain(v) {
-    return is$typed(v, id, hashMain);
-}
-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
-});
-
-/**
- * Hypercert lexicon definitions for AT Protocol.
- *
- * This module exports the lexicon documents, collection names,
- * and generated TypeScript types for all hypercert-related record types.
- *
- * @packageDocumentation
- */
-/**
- * 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.
- *
- * 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",
-};
-
-exports.AppCertifiedDefs = defs;
-exports.AppCertifiedLocation = location;
-exports.ComAtprotoRepoStrongRef = strongRef;
-exports.HYPERCERT_COLLECTIONS = HYPERCERT_COLLECTIONS;
-exports.HYPERCERT_LEXICONS = HYPERCERT_LEXICONS;
-exports.OrgHypercertsClaim = claim;
-exports.OrgHypercertsClaimContribution = contribution;
-exports.OrgHypercertsClaimEvaluation = evaluation;
-exports.OrgHypercertsClaimEvidence = evidence;
-exports.OrgHypercertsClaimMeasurement = measurement;
-exports.OrgHypercertsClaimRights = rights;
-exports.OrgHypercertsCollection = collection;
-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.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;
-//# sourceMappingURL=index.cjs.map