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

package/dist/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/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/lexicons.mjs

@@ -308,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',
@@ -890,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: {
@@ -958,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);
@@ -986,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 };