@hypercerts-org/lexicon 0.10.0-beta.6 → 0.10.0-beta.8

package/dist/lexicons.mjs

@@ -273,16 +273,32 @@ const schemaDict = {
                         },
                         shortDescription: {
                             type: 'string',
-                            description: 'Short blurb of the impact work done.',
+                            description: 'Short summary of this activity claim, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
                             maxLength: 3000,
                             maxGraphemes: 300,
                         },
+                        shortDescriptionFacets: {
+                            type: 'array',
+                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.bsky.richtext.facet',
+                            },
+                        },
                         description: {
                             type: 'string',
-                            description: 'Optional longer description of the impact work done.',
+                            description: 'Optional longer description of this activity claim, including context or interpretation. Rich text annotations may be provided via `descriptionFacets`.',
                             maxLength: 30000,
                             maxGraphemes: 3000,
                         },
+                        descriptionFacets: {
+                            type: 'array',
+                            description: 'Rich text annotations for `description` (mentions, URLs, hashtags, etc).',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.bsky.richtext.facet',
+                            },
+                        },
                         image: {
                             type: 'union',
                             refs: [
@@ -292,9 +308,14 @@ const schemaDict = {
                             description: 'The hypercert visual representation as a URI or image blob.',
                         },
                         workScope: {
-                            type: 'ref',
-                            ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to a record defining the scope of work. The record referenced should describe the logical scope using label-based conditions.',
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#workScopeAll',
+                                'lex:org.hypercerts.defs#workScopeAny',
+                                'lex:org.hypercerts.defs#workScopeNot',
+                                'lex:org.hypercerts.defs#workScopeAtom',
+                            ],
+                            description: 'Work scope logic expression using boolean operators (all/any/not) and atomic scope references.',
                         },
                         startDate: {
                             type: 'string',
@@ -337,17 +358,17 @@ const schemaDict = {
             },
             contributor: {
                 type: 'object',
-                required: ['contributorInformation'],
+                required: ['contributorIdentity'],
                 properties: {
-                    contributorInformation: {
+                    contributorIdentity: {
                         type: 'union',
                         refs: [
                             'lex:org.hypercerts.claim.activity#contributorIdentity',
                             'lex:com.atproto.repo.strongRef',
                         ],
-                        description: 'Contributor information as a string (DID or identifier) or strong reference to for instance org.hypercerts.claim.contributorInformation#main.',
+                        description: 'Contributor identity as a string (DID or identifier) via org.hypercerts.claim.activity#contributorIdentity, or a strong reference to a contributor information record.',
                     },
-                    weight: {
+                    contributionWeight: {
                         type: 'string',
                         description: 'The relative weight/importance of this contribution (stored as a string to avoid float precision issues). Must be a positive numeric value. Weights do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
                     },
@@ -357,7 +378,7 @@ const schemaDict = {
                             'lex:org.hypercerts.claim.activity#contributorRole',
                             'lex:com.atproto.repo.strongRef',
                         ],
-                        description: 'Contribution details as a string or strong reference to org.hypercerts.claim.contributionDetails#main.',
+                        description: 'Contribution details as a string via org.hypercerts.claim.activity#contributorRole, or a strong reference to a contribution details record.',
                     },
                 },
             },
@@ -371,21 +392,6 @@ const schemaDict = {
                 maxLength: 10000,
                 maxGraphemes: 1000,
             },
-            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: {
@@ -421,12 +427,28 @@ const schemaDict = {
                             ref: 'lex:pub.leaflet.pages.linearDocument#main',
                             description: 'Rich-text description, represented as a Leaflet linear document.',
                         },
+                        avatar: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: "The collection's avatar/profile image as a URI or image blob.",
+                        },
+                        banner: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#largeImage',
+                            ],
+                            description: 'Larger horizontal image to display behind the collection view.',
+                        },
                         items: {
                             type: 'array',
-                            description: 'Array of strong references to items in this collection. Items can be activities (org.hypercerts.claim.activity) and/or other collections (org.hypercerts.claim.collection).',
+                            description: 'Array of items in this collection with optional weights.',
                             items: {
                                 type: 'ref',
-                                ref: 'lex:com.atproto.repo.strongRef',
+                                ref: 'lex:org.hypercerts.claim.collection#item',
                             },
                         },
                         createdAt: {
@@ -437,6 +459,21 @@ const schemaDict = {
                     },
                 },
             },
+            item: {
+                type: 'object',
+                required: ['itemIdentifier'],
+                properties: {
+                    itemIdentifier: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                        description: 'Strong reference to an item in this collection. Items can be activities (org.hypercerts.claim.activity) and/or other collections (org.hypercerts.claim.collection).',
+                    },
+                    itemWeight: {
+                        type: 'string',
+                        description: 'Optional weight for this item (positive numeric value stored as string). Weights do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
+                    },
+                },
+            },
         },
     },
     OrgHypercertsClaimContributionDetails: {
@@ -858,6 +895,94 @@ const schemaDict = {
                     },
                 },
             },
+            workScopeAll: {
+                type: 'object',
+                required: ['op', 'args'],
+                description: 'Logical AND operation: all arguments must be satisfied.',
+                properties: {
+                    op: {
+                        type: 'string',
+                        const: 'all',
+                        description: "Operator type: 'all' (logical AND)",
+                    },
+                    args: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#workScopeAll',
+                                'lex:org.hypercerts.defs#workScopeAny',
+                                'lex:org.hypercerts.defs#workScopeNot',
+                                'lex:org.hypercerts.defs#workScopeAtom',
+                            ],
+                        },
+                        minLength: 1,
+                        maxLength: 100,
+                        description: 'Array of work scope expressions that must all be satisfied',
+                    },
+                },
+            },
+            workScopeAny: {
+                type: 'object',
+                required: ['op', 'args'],
+                description: 'Logical OR operation: at least one argument must be satisfied.',
+                properties: {
+                    op: {
+                        type: 'string',
+                        const: 'any',
+                        description: "Operator type: 'any' (logical OR)",
+                    },
+                    args: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#workScopeAll',
+                                'lex:org.hypercerts.defs#workScopeAny',
+                                'lex:org.hypercerts.defs#workScopeNot',
+                                'lex:org.hypercerts.defs#workScopeAtom',
+                            ],
+                        },
+                        minLength: 1,
+                        maxLength: 100,
+                        description: 'Array of work scope expressions, at least one of which must be satisfied',
+                    },
+                },
+            },
+            workScopeNot: {
+                type: 'object',
+                required: ['op', 'arg'],
+                description: 'Logical NOT operation: the argument must not be satisfied.',
+                properties: {
+                    op: {
+                        type: 'string',
+                        const: 'not',
+                        description: "Operator type: 'not' (logical NOT)",
+                    },
+                    arg: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.defs#workScopeAll',
+                            'lex:org.hypercerts.defs#workScopeAny',
+                            'lex:org.hypercerts.defs#workScopeNot',
+                            'lex:org.hypercerts.defs#workScopeAtom',
+                        ],
+                        description: 'Work scope expression that must not be satisfied',
+                    },
+                },
+            },
+            workScopeAtom: {
+                type: 'object',
+                required: ['atom'],
+                description: 'Atomic scope reference: a strong reference to a scope record.',
+                properties: {
+                    atom: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                        description: 'Strong reference to an org.hypercerts.helper.workScopeTag record',
+                    },
+                },
+            },
         },
     },
     OrgHypercertsFundingReceipt: {
@@ -926,6 +1051,71 @@ const schemaDict = {
             },
         },
     },
+    OrgHypercertsHelperWorkScopeTag: {
+        lexicon: 1,
+        id: 'org.hypercerts.helper.workScopeTag',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'A reusable scope atom for work scope logic expressions. Scopes can represent topics, languages, domains, deliverables, methods, regions, tags, or other categorical labels.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['createdAt', 'key', 'label'],
+                    properties: {
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                        key: {
+                            type: 'string',
+                            description: "Lowercase, hyphenated machine-readable key for this scope (e.g., 'ipfs', 'go-lang', 'filecoin').",
+                            maxLength: 120,
+                        },
+                        label: {
+                            type: 'string',
+                            description: 'Human-readable label for this scope.',
+                            maxLength: 200,
+                        },
+                        kind: {
+                            type: 'string',
+                            description: 'Category type of this scope. Recommended values: topic, language, domain, method, tag.',
+                            maxLength: 50,
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Optional longer description of this scope.',
+                            maxLength: 10000,
+                            maxGraphemes: 1000,
+                        },
+                        parent: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Optional strong reference to a parent scope record for taxonomy/hierarchy support.',
+                        },
+                        aliases: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                                maxLength: 200,
+                            },
+                            maxLength: 50,
+                            description: 'Optional array of alternative names or identifiers for this scope.',
+                        },
+                        externalReference: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallBlob',
+                            ],
+                            description: 'Optional external reference for this scope as a URI or blob.',
+                        },
+                    },
+                },
+            },
+        },
+    },
 };
 const schemas = Object.values(schemaDict);
 const lexicons = new Lexicons(schemas);
@@ -954,6 +1144,7 @@ const ids = {
     OrgHypercertsClaimRights: 'org.hypercerts.claim.rights',
     OrgHypercertsDefs: 'org.hypercerts.defs',
     OrgHypercertsFundingReceipt: 'org.hypercerts.funding.receipt',
+    OrgHypercertsHelperWorkScopeTag: 'org.hypercerts.helper.workScopeTag',
 };
 
 export { ids, lexicons, schemaDict, schemas, validate };