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

package/dist/generated/lexicons.d.ts

@@ -263,9 +263,9 @@ export declare const schemaDict: {
                             readonly description: "The hypercert visual representation as a URI or image blob.";
                         };
                         readonly workScope: {
-                            readonly type: "ref";
-                            readonly ref: "lex:com.atproto.repo.strongRef";
-                            readonly description: "A strong reference to a record defining the scope of work. The record referenced should describe the logical scope using label-based conditions.";
+                            readonly type: "union";
+                            readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                            readonly description: "Work scope logic expression using boolean operators (all/any/not) and atomic scope references.";
                         };
                         readonly startDate: {
                             readonly type: "string";
@@ -816,6 +816,79 @@ export declare const schemaDict: {
                     };
                 };
             };
+            readonly workScopeAll: {
+                readonly type: "object";
+                readonly required: ["op", "args"];
+                readonly description: "Logical AND operation: all arguments must be satisfied.";
+                readonly properties: {
+                    readonly op: {
+                        readonly type: "string";
+                        readonly const: "all";
+                        readonly description: "Operator type: 'all' (logical AND)";
+                    };
+                    readonly args: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "union";
+                            readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                        };
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                        readonly description: "Array of work scope expressions that must all be satisfied";
+                    };
+                };
+            };
+            readonly workScopeAny: {
+                readonly type: "object";
+                readonly required: ["op", "args"];
+                readonly description: "Logical OR operation: at least one argument must be satisfied.";
+                readonly properties: {
+                    readonly op: {
+                        readonly type: "string";
+                        readonly const: "any";
+                        readonly description: "Operator type: 'any' (logical OR)";
+                    };
+                    readonly args: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "union";
+                            readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                        };
+                        readonly minLength: 1;
+                        readonly maxLength: 100;
+                        readonly description: "Array of work scope expressions, at least one of which must be satisfied";
+                    };
+                };
+            };
+            readonly workScopeNot: {
+                readonly type: "object";
+                readonly required: ["op", "arg"];
+                readonly description: "Logical NOT operation: the argument must not be satisfied.";
+                readonly properties: {
+                    readonly op: {
+                        readonly type: "string";
+                        readonly const: "not";
+                        readonly description: "Operator type: 'not' (logical NOT)";
+                    };
+                    readonly arg: {
+                        readonly type: "union";
+                        readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                        readonly description: "Work scope expression that must not be satisfied";
+                    };
+                };
+            };
+            readonly workScopeAtom: {
+                readonly type: "object";
+                readonly required: ["atom"];
+                readonly description: "Atomic scope reference: a strong reference to a scope record.";
+                readonly properties: {
+                    readonly atom: {
+                        readonly type: "ref";
+                        readonly ref: "lex:com.atproto.repo.strongRef";
+                        readonly description: "Strong reference to an org.hypercerts.helper.workScopeTag record";
+                    };
+                };
+            };
         };
     };
     readonly OrgHypercertsFundingReceipt: {
@@ -884,6 +957,68 @@ export declare const schemaDict: {
             };
         };
     };
+    readonly OrgHypercertsHelperWorkScopeTag: {
+        readonly lexicon: 1;
+        readonly id: "org.hypercerts.helper.workScopeTag";
+        readonly defs: {
+            readonly main: {
+                readonly type: "record";
+                readonly description: "A reusable scope atom for work scope logic expressions. Scopes can represent topics, languages, domains, deliverables, methods, regions, tags, or other categorical labels.";
+                readonly key: "tid";
+                readonly record: {
+                    readonly type: "object";
+                    readonly required: ["createdAt", "key", "label"];
+                    readonly properties: {
+                        readonly createdAt: {
+                            readonly type: "string";
+                            readonly format: "datetime";
+                            readonly description: "Client-declared timestamp when this record was originally created";
+                        };
+                        readonly key: {
+                            readonly type: "string";
+                            readonly description: "Lowercase, hyphenated machine-readable key for this scope (e.g., 'ipfs', 'go-lang', 'filecoin').";
+                            readonly maxLength: 120;
+                        };
+                        readonly label: {
+                            readonly type: "string";
+                            readonly description: "Human-readable label for this scope.";
+                            readonly maxLength: 200;
+                        };
+                        readonly kind: {
+                            readonly type: "string";
+                            readonly description: "Category type of this scope. Recommended values: topic, language, domain, method, tag.";
+                            readonly maxLength: 50;
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                            readonly description: "Optional longer description of this scope.";
+                            readonly maxLength: 10000;
+                            readonly maxGraphemes: 1000;
+                        };
+                        readonly parent: {
+                            readonly type: "ref";
+                            readonly ref: "lex:com.atproto.repo.strongRef";
+                            readonly description: "Optional strong reference to a parent scope record for taxonomy/hierarchy support.";
+                        };
+                        readonly aliases: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly maxLength: 200;
+                            };
+                            readonly maxLength: 50;
+                            readonly description: "Optional array of alternative names or identifiers for this scope.";
+                        };
+                        readonly externalReference: {
+                            readonly type: "union";
+                            readonly refs: ["lex:org.hypercerts.defs#uri", "lex:org.hypercerts.defs#smallBlob"];
+                            readonly description: "Optional external reference for this scope as a URI or blob.";
+                        };
+                    };
+                };
+            };
+        };
+    };
 };
 export declare const schemas: ({
     readonly lexicon: 1;
@@ -1139,9 +1274,9 @@ export declare const schemas: ({
                         readonly description: "The hypercert visual representation as a URI or image blob.";
                     };
                     readonly workScope: {
-                        readonly type: "ref";
-                        readonly ref: "lex:com.atproto.repo.strongRef";
-                        readonly description: "A strong reference to a record defining the scope of work. The record referenced should describe the logical scope using label-based conditions.";
+                        readonly type: "union";
+                        readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                        readonly description: "Work scope logic expression using boolean operators (all/any/not) and atomic scope references.";
                     };
                     readonly startDate: {
                         readonly type: "string";
@@ -1684,6 +1819,79 @@ export declare const schemas: ({
                 };
             };
         };
+        readonly workScopeAll: {
+            readonly type: "object";
+            readonly required: ["op", "args"];
+            readonly description: "Logical AND operation: all arguments must be satisfied.";
+            readonly properties: {
+                readonly op: {
+                    readonly type: "string";
+                    readonly const: "all";
+                    readonly description: "Operator type: 'all' (logical AND)";
+                };
+                readonly args: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "union";
+                        readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                    };
+                    readonly minLength: 1;
+                    readonly maxLength: 100;
+                    readonly description: "Array of work scope expressions that must all be satisfied";
+                };
+            };
+        };
+        readonly workScopeAny: {
+            readonly type: "object";
+            readonly required: ["op", "args"];
+            readonly description: "Logical OR operation: at least one argument must be satisfied.";
+            readonly properties: {
+                readonly op: {
+                    readonly type: "string";
+                    readonly const: "any";
+                    readonly description: "Operator type: 'any' (logical OR)";
+                };
+                readonly args: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "union";
+                        readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                    };
+                    readonly minLength: 1;
+                    readonly maxLength: 100;
+                    readonly description: "Array of work scope expressions, at least one of which must be satisfied";
+                };
+            };
+        };
+        readonly workScopeNot: {
+            readonly type: "object";
+            readonly required: ["op", "arg"];
+            readonly description: "Logical NOT operation: the argument must not be satisfied.";
+            readonly properties: {
+                readonly op: {
+                    readonly type: "string";
+                    readonly const: "not";
+                    readonly description: "Operator type: 'not' (logical NOT)";
+                };
+                readonly arg: {
+                    readonly type: "union";
+                    readonly refs: ["lex:org.hypercerts.defs#workScopeAll", "lex:org.hypercerts.defs#workScopeAny", "lex:org.hypercerts.defs#workScopeNot", "lex:org.hypercerts.defs#workScopeAtom"];
+                    readonly description: "Work scope expression that must not be satisfied";
+                };
+            };
+        };
+        readonly workScopeAtom: {
+            readonly type: "object";
+            readonly required: ["atom"];
+            readonly description: "Atomic scope reference: a strong reference to a scope record.";
+            readonly properties: {
+                readonly atom: {
+                    readonly type: "ref";
+                    readonly ref: "lex:com.atproto.repo.strongRef";
+                    readonly description: "Strong reference to an org.hypercerts.helper.workScopeTag record";
+                };
+            };
+        };
     };
 } | {
     readonly lexicon: 1;
@@ -1750,6 +1958,67 @@ export declare const schemas: ({
             };
         };
     };
+} | {
+    readonly lexicon: 1;
+    readonly id: "org.hypercerts.helper.workScopeTag";
+    readonly defs: {
+        readonly main: {
+            readonly type: "record";
+            readonly description: "A reusable scope atom for work scope logic expressions. Scopes can represent topics, languages, domains, deliverables, methods, regions, tags, or other categorical labels.";
+            readonly key: "tid";
+            readonly record: {
+                readonly type: "object";
+                readonly required: ["createdAt", "key", "label"];
+                readonly properties: {
+                    readonly createdAt: {
+                        readonly type: "string";
+                        readonly format: "datetime";
+                        readonly description: "Client-declared timestamp when this record was originally created";
+                    };
+                    readonly key: {
+                        readonly type: "string";
+                        readonly description: "Lowercase, hyphenated machine-readable key for this scope (e.g., 'ipfs', 'go-lang', 'filecoin').";
+                        readonly maxLength: 120;
+                    };
+                    readonly label: {
+                        readonly type: "string";
+                        readonly description: "Human-readable label for this scope.";
+                        readonly maxLength: 200;
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                        readonly description: "Category type of this scope. Recommended values: topic, language, domain, method, tag.";
+                        readonly maxLength: 50;
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly description: "Optional longer description of this scope.";
+                        readonly maxLength: 10000;
+                        readonly maxGraphemes: 1000;
+                    };
+                    readonly parent: {
+                        readonly type: "ref";
+                        readonly ref: "lex:com.atproto.repo.strongRef";
+                        readonly description: "Optional strong reference to a parent scope record for taxonomy/hierarchy support.";
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly maxLength: 200;
+                        };
+                        readonly maxLength: 50;
+                        readonly description: "Optional array of alternative names or identifiers for this scope.";
+                    };
+                    readonly externalReference: {
+                        readonly type: "union";
+                        readonly refs: ["lex:org.hypercerts.defs#uri", "lex:org.hypercerts.defs#smallBlob"];
+                        readonly description: "Optional external reference for this scope as a URI or blob.";
+                    };
+                };
+            };
+        };
+    };
 })[];
 export declare const lexicons: Lexicons;
 export declare function validate<T extends {
@@ -1775,5 +2044,6 @@ export declare const ids: {
     readonly OrgHypercertsClaimRights: "org.hypercerts.claim.rights";
     readonly OrgHypercertsDefs: "org.hypercerts.defs";
     readonly OrgHypercertsFundingReceipt: "org.hypercerts.funding.receipt";
+    readonly OrgHypercertsHelperWorkScopeTag: "org.hypercerts.helper.workScopeTag";
 };
 //# sourceMappingURL=lexicons.d.ts.map

package/dist/generated/lexicons.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexicons.d.ts","sourceRoot":"","sources":["../../generated/lexicons.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lexicons.d.ts","sourceRoot":"","sources":["../../generated/lexicons.ts"],"names":[],"mappings":"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"}

package/dist/generated/types/org/hypercerts/claim/activity.d.ts

@@ -21,7 +21,9 @@ export interface Main {
     image?: $Typed<OrgHypercertsDefs.Uri> | $Typed<OrgHypercertsDefs.SmallImage> | {
         $type: string;
     };
-    workScope?: ComAtprotoRepoStrongRef.Main;
+    workScope?: $Typed<OrgHypercertsDefs.WorkScopeAll> | $Typed<OrgHypercertsDefs.WorkScopeAny> | $Typed<OrgHypercertsDefs.WorkScopeNot> | $Typed<OrgHypercertsDefs.WorkScopeAtom> | {
+        $type: string;
+    };
     /** When the work began */
     startDate?: string;
     /** When the work ended */

package/dist/generated/types/org/hypercerts/claim/activity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/activity.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,oBAAoB,MAAM,qCAAqC,CAAA;AAChF,OAAO,KAAK,KAAK,iBAAiB,MAAM,YAAY,CAAA;AACpD,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AAMtF,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,+BAA+B,CAAA;IACtC,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,sJAAsJ;IACtJ,gBAAgB,EAAE,MAAM,CAAA;IACxB,oFAAoF;IACpF,sBAAsB,CAAC,EAAE,oBAAoB,CAAC,IAAI,EAAE,CAAA;IACpD,8JAA8J;IAC9J,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,oBAAoB,CAAC,IAAI,EAAE,CAAA;IAC/C,KAAK,CAAC,EACF,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,UAAU,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,SAAS,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACxC,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0BAA0B;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kHAAkH;IAClH,YAAY,CAAC,EAAE,WAAW,EAAE,CAAA;IAC5B,MAAM,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACrC,8JAA8J;IAC9J,SAAS,CAAC,EAAE,uBAAuB,CAAC,IAAI,EAAE,CAAA;IAC1C,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,4FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,2CAA2C,CAAA;IACnD,mBAAmB,EACf,MAAM,CAAC,mBAAmB,CAAC,GAC3B,MAAM,CAAC,uBAAuB,CAAC,IAAI,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,yQAAyQ;IACzQ,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,mBAAmB,CAAC,EAChB,MAAM,CAAC,eAAe,CAAC,GACvB,MAAM,CAAC,uBAAuB,CAAC,IAAI,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CACtB;AAID,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,mGAEpC;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,qCAE1C;AAED,+DAA+D;AAC/D,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAA;AACxC,wCAAwC;AACxC,MAAM,MAAM,eAAe,GAAG,MAAM,CAAA"}
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/claim/activity.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,oBAAoB,MAAM,qCAAqC,CAAA;AAChF,OAAO,KAAK,KAAK,iBAAiB,MAAM,YAAY,CAAA;AACpD,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AAMtF,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,+BAA+B,CAAA;IACtC,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,sJAAsJ;IACtJ,gBAAgB,EAAE,MAAM,CAAA;IACxB,oFAAoF;IACpF,sBAAsB,CAAC,EAAE,oBAAoB,CAAC,IAAI,EAAE,CAAA;IACpD,8JAA8J;IAC9J,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,oBAAoB,CAAC,IAAI,EAAE,CAAA;IAC/C,KAAK,CAAC,EACF,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,UAAU,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,SAAS,CAAC,EACN,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAC,GACtC,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAC,GACtC,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAC,GACtC,MAAM,CAAC,iBAAiB,CAAC,aAAa,CAAC,GACvC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0BAA0B;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kHAAkH;IAClH,YAAY,CAAC,EAAE,WAAW,EAAE,CAAA;IAC5B,MAAM,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACrC,8JAA8J;IAC9J,SAAS,CAAC,EAAE,uBAAuB,CAAC,IAAI,EAAE,CAAA;IAC1C,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,4FAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,2CAA2C,CAAA;IACnD,mBAAmB,EACf,MAAM,CAAC,mBAAmB,CAAC,GAC3B,MAAM,CAAC,uBAAuB,CAAC,IAAI,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,yQAAyQ;IACzQ,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,mBAAmB,CAAC,EAChB,MAAM,CAAC,eAAe,CAAC,GACvB,MAAM,CAAC,uBAAuB,CAAC,IAAI,CAAC,GACpC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CACtB;AAID,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,mGAEpC;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,qCAE1C;AAED,+DAA+D;AAC/D,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAA;AACxC,wCAAwC;AACxC,MAAM,MAAM,eAAe,GAAG,MAAM,CAAA"}

package/dist/generated/types/org/hypercerts/defs.d.ts

@@ -2,6 +2,8 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+import { type $Typed } from '../../../util';
+import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js';
 /** Object containing a URI to external data */
 export interface Uri {
     $type?: 'org.hypercerts.defs#uri';
@@ -42,4 +44,46 @@ export interface LargeImage {
 }
 export declare function isLargeImage<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "largeImage">;
 export declare function validateLargeImage<V>(v: V): ValidationResult<LargeImage & V>;
+/** Logical AND operation: all arguments must be satisfied. */
+export interface WorkScopeAll {
+    $type?: 'org.hypercerts.defs#workScopeAll';
+    /** Operator type: 'all' (logical AND) */
+    op: 'all';
+    /** Array of work scope expressions that must all be satisfied */
+    args: ($Typed<WorkScopeAll> | $Typed<WorkScopeAny> | $Typed<WorkScopeNot> | $Typed<WorkScopeAtom> | {
+        $type: string;
+    })[];
+}
+export declare function isWorkScopeAll<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "workScopeAll">;
+export declare function validateWorkScopeAll<V>(v: V): ValidationResult<WorkScopeAll & V>;
+/** Logical OR operation: at least one argument must be satisfied. */
+export interface WorkScopeAny {
+    $type?: 'org.hypercerts.defs#workScopeAny';
+    /** Operator type: 'any' (logical OR) */
+    op: 'any';
+    /** Array of work scope expressions, at least one of which must be satisfied */
+    args: ($Typed<WorkScopeAll> | $Typed<WorkScopeAny> | $Typed<WorkScopeNot> | $Typed<WorkScopeAtom> | {
+        $type: string;
+    })[];
+}
+export declare function isWorkScopeAny<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "workScopeAny">;
+export declare function validateWorkScopeAny<V>(v: V): ValidationResult<WorkScopeAny & V>;
+/** Logical NOT operation: the argument must not be satisfied. */
+export interface WorkScopeNot {
+    $type?: 'org.hypercerts.defs#workScopeNot';
+    /** Operator type: 'not' (logical NOT) */
+    op: 'not';
+    arg: $Typed<WorkScopeAll> | $Typed<WorkScopeAny> | $Typed<WorkScopeNot> | $Typed<WorkScopeAtom> | {
+        $type: string;
+    };
+}
+export declare function isWorkScopeNot<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "workScopeNot">;
+export declare function validateWorkScopeNot<V>(v: V): ValidationResult<WorkScopeNot & V>;
+/** Atomic scope reference: a strong reference to a scope record. */
+export interface WorkScopeAtom {
+    $type?: 'org.hypercerts.defs#workScopeAtom';
+    atom: ComAtprotoRepoStrongRef.Main;
+}
+export declare function isWorkScopeAtom<V>(v: V): v is import("../../../util").$TypedObject<V, "org.hypercerts.defs", "workScopeAtom">;
+export declare function validateWorkScopeAtom<V>(v: V): ValidationResult<WorkScopeAtom & V>;
 //# sourceMappingURL=defs.d.ts.map

package/dist/generated/types/org/hypercerts/defs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../../../generated/types/org/hypercerts/defs.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AASjE,+CAA+C;AAC/C,MAAM,WAAW,GAAG;IAClB,KAAK,CAAC,EAAE,yBAAyB,CAAA;IACjC,2BAA2B;IAC3B,GAAG,EAAE,MAAM,CAAA;CACZ;AAID,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8EAE5B;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,6BAElC;AAED,gDAAgD;AAChD,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,+BAA+B,CAAA;IACvC,yCAAyC;IACzC,IAAI,EAAE,OAAO,CAAA;CACd;AAID,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oFAElC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,mCAExC;AAED,gDAAgD;AAChD,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,+BAA+B,CAAA;IACvC,0CAA0C;IAC1C,IAAI,EAAE,OAAO,CAAA;CACd;AAID,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oFAElC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,mCAExC;AAED,sCAAsC;AACtC,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,gCAAgC,CAAA;IACxC,wBAAwB;IACxB,KAAK,EAAE,OAAO,CAAA;CACf;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,qFAEnC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oCAEzC;AAED,sCAAsC;AACtC,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,gCAAgC,CAAA;IACxC,yBAAyB;IACzB,KAAK,EAAE,OAAO,CAAA;CACf;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,qFAEnC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,oCAEzC"}
+{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../../../generated/types/org/hypercerts/defs.ts"],"names":[],"mappings":"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"}

package/dist/generated/types/org/hypercerts/helper/workScopeTag.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import { type $Typed } from '../../../../util';
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js';
+import type * as OrgHypercertsDefs from '../defs.js';
+export interface Main {
+    $type: 'org.hypercerts.helper.workScopeTag';
+    /** Client-declared timestamp when this record was originally created */
+    createdAt: string;
+    /** Lowercase, hyphenated machine-readable key for this scope (e.g., 'ipfs', 'go-lang', 'filecoin'). */
+    key: string;
+    /** Human-readable label for this scope. */
+    label: string;
+    /** Category type of this scope. Recommended values: topic, language, domain, method, tag. */
+    kind?: string;
+    /** Optional longer description of this scope. */
+    description?: string;
+    parent?: ComAtprotoRepoStrongRef.Main;
+    /** Optional array of alternative names or identifiers for this scope. */
+    aliases?: string[];
+    externalReference?: $Typed<OrgHypercertsDefs.Uri> | $Typed<OrgHypercertsDefs.SmallBlob> | {
+        $type: string;
+    };
+    [k: string]: unknown;
+}
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "org.hypercerts.helper.workScopeTag", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;
+export { type Main as Record, isMain as isRecord, validateMain as validateRecord, };
+//# sourceMappingURL=workScopeTag.d.ts.map

package/dist/generated/types/org/hypercerts/helper/workScopeTag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workScopeTag.d.ts","sourceRoot":"","sources":["../../../../../../generated/types/org/hypercerts/helper/workScopeTag.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAA;AAGjE,OAAO,EACL,KAAK,MAAM,EAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,uBAAuB,MAAM,wCAAwC,CAAA;AACtF,OAAO,KAAK,KAAK,iBAAiB,MAAM,YAAY,CAAA;AAMpD,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,oCAAoC,CAAA;IAC3C,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;IACjB,uGAAuG;IACvG,GAAG,EAAE,MAAM,CAAA;IACX,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,6FAA6F;IAC7F,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAA;IACrC,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,iBAAiB,CAAC,EACd,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAC7B,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,GACnC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IACrB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CACrB;AAID,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,iGAE7B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,8BAEnC;AAED,OAAO,EACL,KAAK,IAAI,IAAI,MAAM,EACnB,MAAM,IAAI,QAAQ,EAClB,YAAY,IAAI,cAAc,GAC/B,CAAA"}