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

package/dist/index.cjs

@@ -0,0 +1,2636 @@
+'use strict';
+
+var lexicon$g = require('@atproto/lexicon');
+
+/**
+ * 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: {
+            did: {
+                type: 'string',
+                format: 'did',
+                description: 'A Decentralized Identifier (DID) string.',
+            },
+        },
+    },
+    AppCertifiedLocation: {
+        lexicon: 1,
+        id: 'app.certified.location',
+        defs: {
+            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: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex: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',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    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',
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsClaimActivity: {
+        lexicon: 1,
+        id: 'org.hypercerts.claim.activity',
+        defs: {
+            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: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: 'The hypercert visual representation as a URI or image blob.',
+                        },
+                        workScope: {
+                            type: 'ref',
+                            ref: 'lex:org.hypercerts.claim.activity#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: '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 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',
+                            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: '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',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsClaimEvaluation: {
+        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 record (e.g. an activity and its impact).',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['evaluators', 'summary', 'createdAt'],
+                    properties: {
+                        subject: {
+                            type: 'ref',
+                            ref: 'lex: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: 'lex:app.certified.defs#did',
+                            },
+                            maxLength: 1000,
+                        },
+                        content: {
+                            type: 'array',
+                            description: 'Evaluation data (URIs or blobs) containing detailed reports or methodology',
+                            items: {
+                                type: 'union',
+                                refs: [
+                                    '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',
+                            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 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: '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:org.hypercerts.defs#uri',
+                                'lex: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',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsClaimMeasurement: {
+        lexicon: 1,
+        id: 'org.hypercerts.claim.measurement',
+        defs: {
+            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: 'lex: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: 'lex: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: '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',
+                            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 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: [
+                                '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',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    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.funding.receipt',
+        defs: {
+            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: '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 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.',
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+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 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$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$9(v, id$9, hashMain$8);
+}
+function validateMain$8(v) {
+    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 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$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$8(v, id$8, hashMain$7);
+}
+function validateMain$7(v) {
+    return validate$8(v, id$8, hashMain$7, true);
+}
+
+var collection = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$7,
+    isRecord: isMain$7,
+    validateMain: validateMain$7,
+    validateRecord: validateMain$7
+});
+
+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$7(v, id$7, hashMain$6);
+}
+function validateMain$6(v) {
+    return validate$7(v, id$7, hashMain$6, true);
+}
+
+var contribution = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$6,
+    isRecord: isMain$6,
+    validateMain: validateMain$6,
+    validateRecord: validateMain$6
+});
+
+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$6(v, id$6, hashMain$5);
+}
+function validateMain$5(v) {
+    return validate$6(v, id$6, hashMain$5, true);
+}
+
+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$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$5(v, id$5, hashMain$4);
+}
+function validateMain$4(v) {
+    return validate$5(v, id$5, hashMain$4, true);
+}
+
+var evidence = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$4,
+    isRecord: isMain$4,
+    validateMain: validateMain$4,
+    validateRecord: validateMain$4
+});
+
+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$4(v, id$4, hashMain$3);
+}
+function validateMain$3(v) {
+    return validate$4(v, id$4, hashMain$3, true);
+}
+
+var measurement = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$3,
+    isRecord: isMain$3,
+    validateMain: validateMain$3,
+    validateRecord: validateMain$3
+});
+
+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$3(v, id$3, hashMain$2);
+}
+function validateMain$2(v) {
+    return validate$3(v, id$3, hashMain$2, true);
+}
+
+var project = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$2,
+    isRecord: isMain$2,
+    validateMain: validateMain$2,
+    validateRecord: validateMain$2
+});
+
+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$2(v, id$2, hashMain$1);
+}
+function validateMain$1(v) {
+    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
+});
+
+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$f, validate = validate$f;
+const id = 'org.hypercerts.funding.receipt';
+const hashMain = 'main';
+function isMain(v) {
+    return is$typed(v, id, hashMain);
+}
+function validateMain(v) {
+    return validate(v, id, hashMain, true);
+}
+
+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,
+ * and generated TypeScript types for all hypercert-related record types.
+ *
+ * @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";
+/**
+ * Collection NSIDs organized by semantic record type.
+ *
+ * Use these constants when performing record operations to ensure
+ * correct collection names.
+ */
+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.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.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.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.is$typed = is$typed$f;
+exports.lexicons = lexicons;
+exports.maybe$typed = maybe$typed;
+exports.validate = validate$f;
+//# sourceMappingURL=index.cjs.map