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

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var lexicon$g = require('@atproto/lexicon');
+var lexicon$h = require('@atproto/lexicon');
 
 /**
  * GENERATED CODE - DO NOT MODIFY
@@ -18,7 +18,7 @@ function is$type($type, id, hash) {
                 $type.startsWith(id) &&
                 $type.endsWith(hash);
 }
-function is$typed$f(v, id, hash) {
+function is$typed$g(v, id, hash) {
     return isObject(v) && '$type' in v && is$type(v.$type, id, hash);
 }
 function maybe$typed(v, id, hash) {
@@ -319,9 +319,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',
@@ -901,6 +906,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: {
@@ -969,15 +1062,80 @@ 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 lexicon$g.Lexicons(schemas);
-function validate$f(v, id, hash, requiredType) {
-    return (requiredType ? is$typed$f : maybe$typed)(v, id, hash)
+const lexicons = new lexicon$h.Lexicons(schemas);
+function validate$g(v, id, hash, requiredType) {
+    return (requiredType ? is$typed$g : 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`),
+            error: new lexicon$h.ValidationError(`Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`),
         };
 }
 const ids = {
@@ -997,11 +1155,12 @@ const ids = {
     OrgHypercertsClaimRights: 'org.hypercerts.claim.rights',
     OrgHypercertsDefs: 'org.hypercerts.defs',
     OrgHypercertsFundingReceipt: 'org.hypercerts.funding.receipt',
+    OrgHypercertsHelperWorkScopeTag: 'org.hypercerts.helper.workScopeTag',
 };
 
-var lexicon$f = 1;
-var id$u = "app.certified.badge.award";
-var defs$h = {
+var lexicon$g = 1;
+var id$w = "app.certified.badge.award";
+var defs$i = {
 	main: {
 		type: "record",
 		description: "Records a badge award to a user, project, or activity claim.",
@@ -1041,14 +1200,14 @@ var defs$h = {
 	}
 };
 var BADGE_AWARD_LEXICON_JSON = {
-	lexicon: lexicon$f,
-	id: id$u,
-	defs: defs$h
+	lexicon: lexicon$g,
+	id: id$w,
+	defs: defs$i
 };
 
-var lexicon$e = 1;
-var id$t = "app.certified.badge.definition";
-var defs$g = {
+var lexicon$f = 1;
+var id$v = "app.certified.badge.definition";
+var defs$h = {
 	main: {
 		type: "record",
 		description: "Defines a badge that can be awarded via badge award records to users, projects, or activity claims.",
@@ -1103,14 +1262,14 @@ var defs$g = {
 	}
 };
 var BADGE_DEFINITION_LEXICON_JSON = {
-	lexicon: lexicon$e,
-	id: id$t,
-	defs: defs$g
+	lexicon: lexicon$f,
+	id: id$v,
+	defs: defs$h
 };
 
-var lexicon$d = 1;
-var id$s = "app.certified.badge.response";
-var defs$f = {
+var lexicon$e = 1;
+var id$u = "app.certified.badge.response";
+var defs$g = {
 	main: {
 		type: "record",
 		description: "Recipient response to a badge award.",
@@ -1150,15 +1309,15 @@ var defs$f = {
 	}
 };
 var BADGE_RESPONSE_LEXICON_JSON = {
-	lexicon: lexicon$d,
-	id: id$s,
-	defs: defs$f
+	lexicon: lexicon$e,
+	id: id$u,
+	defs: defs$g
 };
 
-var lexicon$c = 1;
-var id$r = "app.certified.defs";
+var lexicon$d = 1;
+var id$t = "app.certified.defs";
 var description$1 = "Common type definitions used across certified protocols.";
-var defs$e = {
+var defs$f = {
 	did: {
 		type: "string",
 		format: "did",
@@ -1166,15 +1325,15 @@ var defs$e = {
 	}
 };
 var CERTIFIED_DEFS_LEXICON_JSON = {
-	lexicon: lexicon$c,
-	id: id$r,
+	lexicon: lexicon$d,
+	id: id$t,
 	description: description$1,
-	defs: defs$e
+	defs: defs$f
 };
 
-var lexicon$b = 1;
-var id$q = "app.certified.location";
-var defs$d = {
+var lexicon$c = 1;
+var id$s = "app.certified.location";
+var defs$e = {
 	main: {
 		type: "record",
 		description: "A location reference",
@@ -1239,15 +1398,15 @@ var defs$d = {
 	}
 };
 var LOCATION_LEXICON_JSON = {
-	lexicon: lexicon$b,
-	id: id$q,
-	defs: defs$d
+	lexicon: lexicon$c,
+	id: id$s,
+	defs: defs$e
 };
 
-var lexicon$a = 1;
-var id$p = "com.atproto.repo.strongRef";
+var lexicon$b = 1;
+var id$r = "com.atproto.repo.strongRef";
 var description = "A URI with a content-hash fingerprint.";
-var defs$c = {
+var defs$d = {
 	main: {
 		type: "object",
 		required: [
@@ -1267,15 +1426,15 @@ var defs$c = {
 	}
 };
 var STRONGREF_LEXICON_JSON = {
-	lexicon: lexicon$a,
-	id: id$p,
+	lexicon: lexicon$b,
+	id: id$r,
 	description: description,
-	defs: defs$c
+	defs: defs$d
 };
 
-var lexicon$9 = 1;
-var id$o = "org.hypercerts.claim.activity";
-var defs$b = {
+var lexicon$a = 1;
+var id$q = "org.hypercerts.claim.activity";
+var defs$c = {
 	main: {
 		type: "record",
 		description: "A hypercert record tracking impact work.",
@@ -1330,9 +1489,14 @@ var defs$b = {
 					description: "The hypercert visual representation as a URI or image blob."
 				},
 				workScope: {
-					type: "ref",
-					ref: "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: [
+						"org.hypercerts.defs#workScopeAll",
+						"org.hypercerts.defs#workScopeAny",
+						"org.hypercerts.defs#workScopeNot",
+						"org.hypercerts.defs#workScopeAtom"
+					],
+					description: "Work scope logic expression using boolean operators (all/any/not) and atomic scope references."
 				},
 				startDate: {
 					type: "string",
@@ -1413,14 +1577,14 @@ var defs$b = {
 	}
 };
 var ACTIVITY_LEXICON_JSON = {
-	lexicon: lexicon$9,
-	id: id$o,
-	defs: defs$b
+	lexicon: lexicon$a,
+	id: id$q,
+	defs: defs$c
 };
 
-var lexicon$8 = 1;
-var id$n = "org.hypercerts.claim.collection";
-var defs$a = {
+var lexicon$9 = 1;
+var id$p = "org.hypercerts.claim.collection";
+var defs$b = {
 	main: {
 		type: "record",
 		description: "A collection/group of items (activities and/or other collections). Collections support recursive nesting. Use app.certified.location as a sidecar (same TID) for location metadata.",
@@ -1505,14 +1669,14 @@ var defs$a = {
 	}
 };
 var COLLECTION_LEXICON_JSON = {
-	lexicon: lexicon$8,
-	id: id$n,
-	defs: defs$a
+	lexicon: lexicon$9,
+	id: id$p,
+	defs: defs$b
 };
 
-var lexicon$7 = 1;
-var id$m = "org.hypercerts.claim.contributionDetails";
-var defs$9 = {
+var lexicon$8 = 1;
+var id$o = "org.hypercerts.claim.contributionDetails";
+var defs$a = {
 	main: {
 		type: "record",
 		description: "Details about a specific contribution including role, description, and timeframe.",
@@ -1554,14 +1718,14 @@ var defs$9 = {
 	}
 };
 var CONTRIBUTIONDETAILS_LEXICON_JSON = {
-	lexicon: lexicon$7,
-	id: id$m,
-	defs: defs$9
+	lexicon: lexicon$8,
+	id: id$o,
+	defs: defs$a
 };
 
-var lexicon$6 = 1;
-var id$l = "org.hypercerts.claim.contributorInformation";
-var defs$8 = {
+var lexicon$7 = 1;
+var id$n = "org.hypercerts.claim.contributorInformation";
+var defs$9 = {
 	main: {
 		type: "record",
 		description: "Contributor information including identifier, display name, and image.",
@@ -1599,14 +1763,14 @@ var defs$8 = {
 	}
 };
 var CONTRIBUTORINFORMATION_LEXICON_JSON = {
-	lexicon: lexicon$6,
-	id: id$l,
-	defs: defs$8
+	lexicon: lexicon$7,
+	id: id$n,
+	defs: defs$9
 };
 
-var lexicon$5 = 1;
-var id$k = "org.hypercerts.claim.evaluation";
-var defs$7 = {
+var lexicon$6 = 1;
+var id$m = "org.hypercerts.claim.evaluation";
+var defs$8 = {
 	score: {
 		type: "object",
 		description: "Overall score for an evaluation on a numeric scale.",
@@ -1703,14 +1867,14 @@ var defs$7 = {
 	}
 };
 var EVALUATION_LEXICON_JSON = {
-	lexicon: lexicon$5,
-	id: id$k,
-	defs: defs$7
+	lexicon: lexicon$6,
+	id: id$m,
+	defs: defs$8
 };
 
-var lexicon$4 = 1;
-var id$j = "org.hypercerts.claim.evidence";
-var defs$6 = {
+var lexicon$5 = 1;
+var id$l = "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.",
@@ -1772,14 +1936,14 @@ var defs$6 = {
 	}
 };
 var EVIDENCE_LEXICON_JSON = {
-	lexicon: lexicon$4,
-	id: id$j,
-	defs: defs$6
+	lexicon: lexicon$5,
+	id: id$l,
+	defs: defs$7
 };
 
-var lexicon$3 = 1;
-var id$i = "org.hypercerts.claim.measurement";
-var defs$5 = {
+var lexicon$4 = 1;
+var id$k = "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).",
@@ -1851,14 +2015,14 @@ var defs$5 = {
 	}
 };
 var MEASUREMENT_LEXICON_JSON = {
-	lexicon: lexicon$3,
-	id: id$i,
-	defs: defs$5
+	lexicon: lexicon$4,
+	id: id$k,
+	defs: defs$6
 };
 
-var lexicon$2 = 1;
-var id$h = "org.hypercerts.claim.rights";
-var defs$4 = {
+var lexicon$3 = 1;
+var id$j = "org.hypercerts.claim.rights";
+var defs$5 = {
 	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.",
@@ -1904,14 +2068,14 @@ var defs$4 = {
 	}
 };
 var RIGHTS_LEXICON_JSON = {
-	lexicon: lexicon$2,
-	id: id$h,
-	defs: defs$4
+	lexicon: lexicon$3,
+	id: id$j,
+	defs: defs$5
 };
 
-var lexicon$1 = 1;
-var id$g = "org.hypercerts.defs";
-var defs$3 = {
+var lexicon$2 = 1;
+var id$i = "org.hypercerts.defs";
+var defs$4 = {
 	uri: {
 		type: "object",
 		required: [
@@ -2000,17 +2164,116 @@ var defs$3 = {
 				description: "Image (up to 10MB)"
 			}
 		}
+	},
+	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: [
+						"#workScopeAll",
+						"#workScopeAny",
+						"#workScopeNot",
+						"#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: [
+						"#workScopeAll",
+						"#workScopeAny",
+						"#workScopeNot",
+						"#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: [
+					"#workScopeAll",
+					"#workScopeAny",
+					"#workScopeNot",
+					"#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: "com.atproto.repo.strongRef",
+				description: "Strong reference to an org.hypercerts.helper.workScopeTag record"
+			}
+		}
 	}
 };
 var HYPERCERTS_DEFS_LEXICON_JSON = {
-	lexicon: lexicon$1,
-	id: id$g,
-	defs: defs$3
+	lexicon: lexicon$2,
+	id: id$i,
+	defs: defs$4
 };
 
-var lexicon = 1;
-var id$f = "org.hypercerts.funding.receipt";
-var defs$2 = {
+var lexicon$1 = 1;
+var id$h = "org.hypercerts.funding.receipt";
+var defs$3 = {
 	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.",
@@ -2079,13 +2342,104 @@ var defs$2 = {
 	}
 };
 var FUNDING_RECEIPT_LEXICON_JSON = {
+	lexicon: lexicon$1,
+	id: id$h,
+	defs: defs$3
+};
+
+var lexicon = 1;
+var id$g = "org.hypercerts.helper.workScopeTag";
+var defs$2 = {
+	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: "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: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallBlob"
+					],
+					description: "Optional external reference for this scope as a URI or blob."
+				}
+			}
+		}
+	}
+};
+var HELPER_WORKSCOPETAG_LEXICON_JSON = {
 	lexicon: lexicon,
-	id: id$f,
+	id: id$g,
 	defs: defs$2
 };
 
-const is$typed$e = is$typed$f, validate$e = validate$f;
-const id$e = 'app.certified.badge.award';
+const is$typed$f = is$typed$g, validate$f = validate$g;
+const id$f = 'app.certified.badge.award';
+const hashMain$e = 'main';
+function isMain$e(v) {
+    return is$typed$f(v, id$f, hashMain$e);
+}
+function validateMain$e(v) {
+    return validate$f(v, id$f, hashMain$e, true);
+}
+
+var award = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$e,
+    isRecord: isMain$e,
+    validateMain: validateMain$e,
+    validateRecord: validateMain$e
+});
+
+const is$typed$e = is$typed$g, validate$e = validate$g;
+const id$e = 'app.certified.badge.definition';
 const hashMain$d = 'main';
 function isMain$d(v) {
     return is$typed$e(v, id$e, hashMain$d);
@@ -2094,7 +2448,7 @@ function validateMain$d(v) {
     return validate$e(v, id$e, hashMain$d, true);
 }
 
-var award = /*#__PURE__*/Object.freeze({
+var definition = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$d,
     isRecord: isMain$d,
@@ -2102,8 +2456,8 @@ var award = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$d
 });
 
-const is$typed$d = is$typed$f, validate$d = validate$f;
-const id$d = 'app.certified.badge.definition';
+const is$typed$d = is$typed$g, validate$d = validate$g;
+const id$d = 'app.certified.badge.response';
 const hashMain$c = 'main';
 function isMain$c(v) {
     return is$typed$d(v, id$d, hashMain$c);
@@ -2112,7 +2466,7 @@ function validateMain$c(v) {
     return validate$d(v, id$d, hashMain$c, true);
 }
 
-var definition = /*#__PURE__*/Object.freeze({
+var response = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$c,
     isRecord: isMain$c,
@@ -2120,8 +2474,12 @@ var definition = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$c
 });
 
-const is$typed$c = is$typed$f, validate$c = validate$f;
-const id$c = 'app.certified.badge.response';
+var defs$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
+const is$typed$c = is$typed$g, validate$c = validate$g;
+const id$c = 'app.certified.location';
 const hashMain$b = 'main';
 function isMain$b(v) {
     return is$typed$c(v, id$c, hashMain$b);
@@ -2130,7 +2488,7 @@ function validateMain$b(v) {
     return validate$c(v, id$c, hashMain$b, true);
 }
 
-var response = /*#__PURE__*/Object.freeze({
+var location = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$b,
     isRecord: isMain$b,
@@ -2138,46 +2496,51 @@ var response = /*#__PURE__*/Object.freeze({
     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 is$typed$b = is$typed$g, validate$b = validate$g;
+const id$b = 'com.atproto.repo.strongRef';
 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);
+    return validate$b(v, id$b, hashMain$a);
 }
 
-var location = /*#__PURE__*/Object.freeze({
+var strongRef = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$a,
-    isRecord: isMain$a,
-    validateMain: validateMain$a,
-    validateRecord: validateMain$a
+    validateMain: validateMain$a
 });
 
-const is$typed$a = is$typed$f, validate$a = validate$f;
-const id$a = 'com.atproto.repo.strongRef';
+const is$typed$a = is$typed$g, validate$a = validate$g;
+const id$a = 'org.hypercerts.claim.activity';
 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);
+    return validate$a(v, id$a, hashMain$9, true);
+}
+const hashContributor = 'contributor';
+function isContributor(v) {
+    return is$typed$a(v, id$a, hashContributor);
+}
+function validateContributor(v) {
+    return validate$a(v, id$a, hashContributor);
 }
 
-var strongRef = /*#__PURE__*/Object.freeze({
+var activity = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    isContributor: isContributor,
     isMain: isMain$9,
-    validateMain: validateMain$9
+    isRecord: isMain$9,
+    validateContributor: validateContributor,
+    validateMain: validateMain$9,
+    validateRecord: validateMain$9
 });
 
-const is$typed$9 = is$typed$f, validate$9 = validate$f;
-const id$9 = 'org.hypercerts.claim.activity';
+const is$typed$9 = is$typed$g, validate$9 = validate$g;
+const id$9 = 'org.hypercerts.claim.collection';
 const hashMain$8 = 'main';
 function isMain$8(v) {
     return is$typed$9(v, id$9, hashMain$8);
@@ -2185,26 +2548,26 @@ function isMain$8(v) {
 function validateMain$8(v) {
     return validate$9(v, id$9, hashMain$8, true);
 }
-const hashContributor = 'contributor';
-function isContributor(v) {
-    return is$typed$9(v, id$9, hashContributor);
+const hashItem = 'item';
+function isItem(v) {
+    return is$typed$9(v, id$9, hashItem);
 }
-function validateContributor(v) {
-    return validate$9(v, id$9, hashContributor);
+function validateItem(v) {
+    return validate$9(v, id$9, hashItem);
 }
 
-var activity = /*#__PURE__*/Object.freeze({
+var collection = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isContributor: isContributor,
+    isItem: isItem,
     isMain: isMain$8,
     isRecord: isMain$8,
-    validateContributor: validateContributor,
+    validateItem: validateItem,
     validateMain: validateMain$8,
     validateRecord: validateMain$8
 });
 
-const is$typed$8 = is$typed$f, validate$8 = validate$f;
-const id$8 = 'org.hypercerts.claim.collection';
+const is$typed$8 = is$typed$g, validate$8 = validate$g;
+const id$8 = 'org.hypercerts.claim.contributionDetails';
 const hashMain$7 = 'main';
 function isMain$7(v) {
     return is$typed$8(v, id$8, hashMain$7);
@@ -2212,26 +2575,17 @@ function isMain$7(v) {
 function validateMain$7(v) {
     return validate$8(v, id$8, hashMain$7, true);
 }
-const hashItem = 'item';
-function isItem(v) {
-    return is$typed$8(v, id$8, hashItem);
-}
-function validateItem(v) {
-    return validate$8(v, id$8, hashItem);
-}
 
-var collection = /*#__PURE__*/Object.freeze({
+var contributionDetails = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isItem: isItem,
     isMain: isMain$7,
     isRecord: isMain$7,
-    validateItem: validateItem,
     validateMain: validateMain$7,
     validateRecord: validateMain$7
 });
 
-const is$typed$7 = is$typed$f, validate$7 = validate$f;
-const id$7 = 'org.hypercerts.claim.contributionDetails';
+const is$typed$7 = is$typed$g, validate$7 = validate$g;
+const id$7 = 'org.hypercerts.claim.contributorInformation';
 const hashMain$6 = 'main';
 function isMain$6(v) {
     return is$typed$7(v, id$7, hashMain$6);
@@ -2240,7 +2594,7 @@ function validateMain$6(v) {
     return validate$7(v, id$7, hashMain$6, true);
 }
 
-var contributionDetails = /*#__PURE__*/Object.freeze({
+var contributorInformation = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$6,
     isRecord: isMain$6,
@@ -2248,8 +2602,15 @@ var contributionDetails = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$6
 });
 
-const is$typed$6 = is$typed$f, validate$6 = validate$f;
-const id$6 = 'org.hypercerts.claim.contributorInformation';
+const is$typed$6 = is$typed$g, validate$6 = validate$g;
+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);
@@ -2258,23 +2619,18 @@ function validateMain$5(v) {
     return validate$6(v, id$6, hashMain$5, true);
 }
 
-var contributorInformation = /*#__PURE__*/Object.freeze({
+var evaluation = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$5,
     isRecord: isMain$5,
+    isScore: isScore,
     validateMain: validateMain$5,
-    validateRecord: validateMain$5
+    validateRecord: validateMain$5,
+    validateScore: validateScore
 });
 
-const is$typed$5 = is$typed$f, validate$5 = validate$f;
-const id$5 = 'org.hypercerts.claim.evaluation';
-const hashScore = 'score';
-function isScore(v) {
-    return is$typed$5(v, id$5, hashScore);
-}
-function validateScore(v) {
-    return validate$5(v, id$5, hashScore);
-}
+const is$typed$5 = is$typed$g, validate$5 = validate$g;
+const id$5 = 'org.hypercerts.claim.evidence';
 const hashMain$4 = 'main';
 function isMain$4(v) {
     return is$typed$5(v, id$5, hashMain$4);
@@ -2283,18 +2639,16 @@ function validateMain$4(v) {
     return validate$5(v, id$5, hashMain$4, true);
 }
 
-var evaluation = /*#__PURE__*/Object.freeze({
+var evidence = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$4,
     isRecord: isMain$4,
-    isScore: isScore,
     validateMain: validateMain$4,
-    validateRecord: validateMain$4,
-    validateScore: validateScore
+    validateRecord: validateMain$4
 });
 
-const is$typed$4 = is$typed$f, validate$4 = validate$f;
-const id$4 = 'org.hypercerts.claim.evidence';
+const is$typed$4 = is$typed$g, validate$4 = validate$g;
+const id$4 = 'org.hypercerts.claim.measurement';
 const hashMain$3 = 'main';
 function isMain$3(v) {
     return is$typed$4(v, id$4, hashMain$3);
@@ -2303,7 +2657,7 @@ function validateMain$3(v) {
     return validate$4(v, id$4, hashMain$3, true);
 }
 
-var evidence = /*#__PURE__*/Object.freeze({
+var measurement = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$3,
     isRecord: isMain$3,
@@ -2311,8 +2665,8 @@ var evidence = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$3
 });
 
-const is$typed$3 = is$typed$f, validate$3 = validate$f;
-const id$3 = 'org.hypercerts.claim.measurement';
+const is$typed$3 = is$typed$g, validate$3 = validate$g;
+const id$3 = 'org.hypercerts.claim.rights';
 const hashMain$2 = 'main';
 function isMain$2(v) {
     return is$typed$3(v, id$3, hashMain$2);
@@ -2321,7 +2675,7 @@ function validateMain$2(v) {
     return validate$3(v, id$3, hashMain$2, true);
 }
 
-var measurement = /*#__PURE__*/Object.freeze({
+var rights = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$2,
     isRecord: isMain$2,
@@ -2329,60 +2683,70 @@ var measurement = /*#__PURE__*/Object.freeze({
     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 is$typed$2 = is$typed$g, validate$2 = validate$g;
+const id$2 = 'org.hypercerts.defs';
 const hashUri = 'uri';
 function isUri(v) {
-    return is$typed$1(v, id$1, hashUri);
+    return is$typed$2(v, id$2, hashUri);
 }
 function validateUri(v) {
-    return validate$1(v, id$1, hashUri);
+    return validate$2(v, id$2, hashUri);
 }
 const hashSmallBlob = 'smallBlob';
 function isSmallBlob(v) {
-    return is$typed$1(v, id$1, hashSmallBlob);
+    return is$typed$2(v, id$2, hashSmallBlob);
 }
 function validateSmallBlob(v) {
-    return validate$1(v, id$1, hashSmallBlob);
+    return validate$2(v, id$2, hashSmallBlob);
 }
 const hashLargeBlob = 'largeBlob';
 function isLargeBlob(v) {
-    return is$typed$1(v, id$1, hashLargeBlob);
+    return is$typed$2(v, id$2, hashLargeBlob);
 }
 function validateLargeBlob(v) {
-    return validate$1(v, id$1, hashLargeBlob);
+    return validate$2(v, id$2, hashLargeBlob);
 }
 const hashSmallImage = 'smallImage';
 function isSmallImage(v) {
-    return is$typed$1(v, id$1, hashSmallImage);
+    return is$typed$2(v, id$2, hashSmallImage);
 }
 function validateSmallImage(v) {
-    return validate$1(v, id$1, hashSmallImage);
+    return validate$2(v, id$2, hashSmallImage);
 }
 const hashLargeImage = 'largeImage';
 function isLargeImage(v) {
-    return is$typed$1(v, id$1, hashLargeImage);
+    return is$typed$2(v, id$2, hashLargeImage);
 }
 function validateLargeImage(v) {
-    return validate$1(v, id$1, hashLargeImage);
+    return validate$2(v, id$2, hashLargeImage);
+}
+const hashWorkScopeAll = 'workScopeAll';
+function isWorkScopeAll(v) {
+    return is$typed$2(v, id$2, hashWorkScopeAll);
+}
+function validateWorkScopeAll(v) {
+    return validate$2(v, id$2, hashWorkScopeAll);
+}
+const hashWorkScopeAny = 'workScopeAny';
+function isWorkScopeAny(v) {
+    return is$typed$2(v, id$2, hashWorkScopeAny);
+}
+function validateWorkScopeAny(v) {
+    return validate$2(v, id$2, hashWorkScopeAny);
+}
+const hashWorkScopeNot = 'workScopeNot';
+function isWorkScopeNot(v) {
+    return is$typed$2(v, id$2, hashWorkScopeNot);
+}
+function validateWorkScopeNot(v) {
+    return validate$2(v, id$2, hashWorkScopeNot);
+}
+const hashWorkScopeAtom = 'workScopeAtom';
+function isWorkScopeAtom(v) {
+    return is$typed$2(v, id$2, hashWorkScopeAtom);
+}
+function validateWorkScopeAtom(v) {
+    return validate$2(v, id$2, hashWorkScopeAtom);
 }
 
 var defs = /*#__PURE__*/Object.freeze({
@@ -2392,15 +2756,41 @@ var defs = /*#__PURE__*/Object.freeze({
     isSmallBlob: isSmallBlob,
     isSmallImage: isSmallImage,
     isUri: isUri,
+    isWorkScopeAll: isWorkScopeAll,
+    isWorkScopeAny: isWorkScopeAny,
+    isWorkScopeAtom: isWorkScopeAtom,
+    isWorkScopeNot: isWorkScopeNot,
     validateLargeBlob: validateLargeBlob,
     validateLargeImage: validateLargeImage,
     validateSmallBlob: validateSmallBlob,
     validateSmallImage: validateSmallImage,
-    validateUri: validateUri
+    validateUri: validateUri,
+    validateWorkScopeAll: validateWorkScopeAll,
+    validateWorkScopeAny: validateWorkScopeAny,
+    validateWorkScopeAtom: validateWorkScopeAtom,
+    validateWorkScopeNot: validateWorkScopeNot
+});
+
+const is$typed$1 = is$typed$g, validate$1 = validate$g;
+const id$1 = 'org.hypercerts.funding.receipt';
+const hashMain$1 = 'main';
+function isMain$1(v) {
+    return is$typed$1(v, id$1, hashMain$1);
+}
+function validateMain$1(v) {
+    return validate$1(v, id$1, hashMain$1, true);
+}
+
+var receipt = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$1,
+    isRecord: isMain$1,
+    validateMain: validateMain$1,
+    validateRecord: validateMain$1
 });
 
-const is$typed = is$typed$f, validate = validate$f;
-const id = 'org.hypercerts.funding.receipt';
+const is$typed = is$typed$g, validate = validate$g;
+const id = 'org.hypercerts.helper.workScopeTag';
 const hashMain = 'main';
 function isMain(v) {
     return is$typed(v, id, hashMain);
@@ -2409,7 +2799,7 @@ function validateMain(v) {
     return validate(v, id, hashMain, true);
 }
 
-var receipt = /*#__PURE__*/Object.freeze({
+var workScopeTag = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain,
     isRecord: isMain,
@@ -2423,7 +2813,7 @@ var receipt = /*#__PURE__*/Object.freeze({
  * ⚠️  DO NOT EDIT THIS FILE MANUALLY ⚠️
  *
  * This file is automatically generated by scripts/generate-exports.js
- * Generated: 2026-01-21T23:12:40.384Z
+ * Generated: 2026-01-21T23:19:57.583Z
  *
  * To regenerate this file, run:
  *   npm run gen-api
@@ -2456,6 +2846,7 @@ const MEASUREMENT_NSID = "org.hypercerts.claim.measurement";
 const RIGHTS_NSID = "org.hypercerts.claim.rights";
 const HYPERCERTS_DEFS_NSID = "org.hypercerts.defs";
 const FUNDING_RECEIPT_NSID = "org.hypercerts.funding.receipt";
+const HELPER_WORKSCOPETAG_NSID = "org.hypercerts.helper.workScopeTag";
 /**
  * Collection NSIDs organized by semantic record type.
  *
@@ -2479,6 +2870,7 @@ const HYPERCERTS_NSIDS = {
     RIGHTS: RIGHTS_NSID,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_NSID,
     FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,
+    HELPER_WORKSCOPETAG: HELPER_WORKSCOPETAG_NSID,
 };
 /**
  * Lexicon JSON objects organized by semantic record type.
@@ -2500,6 +2892,7 @@ const HYPERCERTS_LEXICON_JSON = {
     RIGHTS: RIGHTS_LEXICON_JSON,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_JSON,
     FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_JSON,
+    HELPER_WORKSCOPETAG: HELPER_WORKSCOPETAG_LEXICON_JSON,
 };
 // Individual lexicon objects (from lexicons.get())
 const BADGE_AWARD_LEXICON_DOC = lexicons.get(BADGE_AWARD_NSID);
@@ -2518,6 +2911,7 @@ const MEASUREMENT_LEXICON_DOC = lexicons.get(MEASUREMENT_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);
+const HELPER_WORKSCOPETAG_LEXICON_DOC = lexicons.get(HELPER_WORKSCOPETAG_NSID);
 /**
  * Lexicon document objects organized by semantic record type.
  */
@@ -2538,6 +2932,7 @@ const HYPERCERTS_LEXICON_DOC = {
     RIGHTS: RIGHTS_LEXICON_DOC,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_DOC,
     FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_DOC,
+    HELPER_WORKSCOPETAG: HELPER_WORKSCOPETAG_LEXICON_DOC,
 };
 
 exports.ACTIVITY_LEXICON_DOC = ACTIVITY_LEXICON_DOC;
@@ -2579,6 +2974,9 @@ 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.HELPER_WORKSCOPETAG_LEXICON_DOC = HELPER_WORKSCOPETAG_LEXICON_DOC;
+exports.HELPER_WORKSCOPETAG_LEXICON_JSON = HELPER_WORKSCOPETAG_LEXICON_JSON;
+exports.HELPER_WORKSCOPETAG_NSID = HELPER_WORKSCOPETAG_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;
@@ -2604,6 +3002,7 @@ exports.OrgHypercertsClaimMeasurement = measurement;
 exports.OrgHypercertsClaimRights = rights;
 exports.OrgHypercertsDefs = defs;
 exports.OrgHypercertsFundingReceipt = receipt;
+exports.OrgHypercertsHelperWorkScopeTag = workScopeTag;
 exports.RIGHTS_LEXICON_DOC = RIGHTS_LEXICON_DOC;
 exports.RIGHTS_LEXICON_JSON = RIGHTS_LEXICON_JSON;
 exports.RIGHTS_NSID = RIGHTS_NSID;
@@ -2611,8 +3010,8 @@ 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.is$typed = is$typed$g;
 exports.lexicons = lexicons;
 exports.maybe$typed = maybe$typed;
-exports.validate = validate$f;
+exports.validate = validate$g;
 //# sourceMappingURL=index.cjs.map