@hypercerts-org/lexicon 0.5.0-beta.0 → 0.7.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypercerts-org/lexicon",
-  "version": "0.5.0-beta.0",
+  "version": "0.7.0-beta.0",
   "description": "ATProto lexicon definitions and TypeScript types for the Hypercerts protocol",
   "type": "module",
   "main": "dist/index.cjs",
@@ -20,7 +20,7 @@
   "files": [
     "dist",
     "lexicons",
-    "src"
+    "README.md"
   ],
   "keywords": [
     "hypercerts",

package/src/index.ts

@@ -1,118 +0,0 @@
-/**
- * Hypercert lexicon definitions for AT Protocol.
- *
- * This module exports the lexicon documents, collection names,
- * and generated TypeScript types for all hypercert-related record types.
- *
- * @packageDocumentation
- */
-
-import defsLexicon from "../lexicons/app/certified/defs.json";
-import locationLexicon from "../lexicons/app/certified/location.json";
-import claimLexicon from "../lexicons/org/hypercerts/claim.json";
-import contributionLexicon from "../lexicons/org/hypercerts/claim/contribution.json";
-import evaluationLexicon from "../lexicons/org/hypercerts/claim/evaluation.json";
-import evidenceLexicon from "../lexicons/org/hypercerts/claim/evidence.json";
-import measurementLexicon from "../lexicons/org/hypercerts/claim/measurement.json";
-import rightsLexicon from "../lexicons/org/hypercerts/claim/rights.json";
-import strongRefLexicon from "../lexicons/com/atproto/repo/strongRef.json";
-import collectionLexicon from "../lexicons/org/hypercerts/collection.json";
-import type { LexiconDoc } from "@atproto/lexicon";
-
-/**
- * All hypercert-related lexicons for registration with AT Protocol Agent.
- *
- * This array contains all lexicon documents needed to work with
- * hypercert records.
- */
-export const HYPERCERT_LEXICONS: LexiconDoc[] = [
-  defsLexicon as LexiconDoc,
-  locationLexicon as LexiconDoc,
-  claimLexicon as LexiconDoc,
-  rightsLexicon as LexiconDoc,
-  contributionLexicon as LexiconDoc,
-  measurementLexicon as LexiconDoc,
-  evaluationLexicon as LexiconDoc,
-  evidenceLexicon as LexiconDoc,
-  collectionLexicon as LexiconDoc,
-];
-
-/**
- * Collection NSIDs (Namespaced Identifiers) for hypercert records.
- *
- * Use these constants when performing record operations to ensure
- * correct collection names.
- */
-export const HYPERCERT_COLLECTIONS = {
-  /**
-   * Main hypercert claim record collection.
-   */
-  CLAIM: "org.hypercerts.claim",
-
-  /**
-   * Rights record collection.
-   */
-  RIGHTS: "org.hypercerts.claim.rights",
-
-  /**
-   * Location record collection (shared certified lexicon).
-   */
-  LOCATION: "app.certified.location",
-
-  /**
-   * Contribution record collection.
-   */
-  CONTRIBUTION: "org.hypercerts.claim.contribution",
-
-  /**
-   * Measurement record collection.
-   */
-  MEASUREMENT: "org.hypercerts.claim.measurement",
-
-  /**
-   * Evaluation record collection.
-   */
-  EVALUATION: "org.hypercerts.claim.evaluation",
-
-  /**
-   * Evidence record collection.
-   */
-  EVIDENCE: "org.hypercerts.claim.evidence",
-
-  /**
-   * Collection record collection (groups of hypercerts).
-   */
-  COLLECTION: "org.hypercerts.collection",
-} as const;
-
-// Re-export individual lexicons for direct access
-export {
-  defsLexicon,
-  locationLexicon,
-  strongRefLexicon,
-  claimLexicon,
-  contributionLexicon,
-  evaluationLexicon,
-  evidenceLexicon,
-  measurementLexicon,
-  rightsLexicon,
-  collectionLexicon,
-};
-
-// Re-export generated types as namespaces (avoiding conflicts)
-export * as AppCertifiedDefs from "./types/app/certified/defs.js";
-export * as AppCertifiedLocation from "./types/app/certified/location.js";
-export * as ComAtprotoRepoStrongRef from "./types/com/atproto/repo/strongRef.js";
-export * as OrgHypercertsClaim from "./types/org/hypercerts/claim.js";
-export * as OrgHypercertsClaimContribution from "./types/org/hypercerts/claim/contribution.js";
-export * as OrgHypercertsClaimEvaluation from "./types/org/hypercerts/claim/evaluation.js";
-export * as OrgHypercertsClaimEvidence from "./types/org/hypercerts/claim/evidence.js";
-export * as OrgHypercertsClaimMeasurement from "./types/org/hypercerts/claim/measurement.js";
-export * as OrgHypercertsClaimRights from "./types/org/hypercerts/claim/rights.js";
-export * as OrgHypercertsCollection from "./types/org/hypercerts/collection.js";
-
-// Re-export lexicon schemas, validation, and IDs
-export { schemas, schemaDict, lexicons, validate, ids } from "./lexicons.js";
-
-// Re-export utilities
-export * from "./util.js";

package/src/lexicons.ts

@@ -1,623 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import {
-  type LexiconDoc,
-  Lexicons,
-  ValidationError,
-  type ValidationResult,
-} from '@atproto/lexicon'
-import { type $Typed, is$typed, maybe$typed } from './util.js'
-
-export const schemaDict = {
-  AppCertifiedDefs: {
-    lexicon: 1,
-    id: 'app.certified.defs',
-    defs: {
-      uri: {
-        type: 'string',
-        format: 'uri',
-        maxGraphemes: 1000,
-        description: 'URI to external data',
-      },
-      smallBlob: {
-        type: 'blob',
-        accept: ['*/*'],
-        maxSize: 10485760,
-        description: 'Blob to external data (up to 10MB)',
-      },
-      largeBlob: {
-        type: 'blob',
-        accept: ['*/*'],
-        maxSize: 104857600,
-        description: 'Blob to external data (up to 100MB)',
-      },
-    },
-  },
-  AppCertifiedLocation: {
-    lexicon: 1,
-    id: 'app.certified.location',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'A location reference',
-        key: 'any',
-        record: {
-          type: 'object',
-          required: [
-            'lpVersion',
-            'srs',
-            'locationType',
-            'location',
-            'createdAt',
-          ],
-          properties: {
-            lpVersion: {
-              type: 'string',
-              description: 'The version of the Location Protocol',
-              maxLength: 10,
-            },
-            srs: {
-              type: 'string',
-              format: 'uri',
-              description:
-                'The Spatial Reference System URI (e.g., http://www.opengis.net/def/crs/OGC/1.3/CRS84) that defines the coordinate system.',
-              maxLength: 100,
-            },
-            locationType: {
-              type: 'string',
-              description:
-                'An identifier for the format of the location data (e.g., coordinate-decimal, geojson-point)',
-              knownValues: ['coordinate-decimal', 'geojson-point'],
-              maxLength: 20,
-            },
-            location: {
-              type: 'union',
-              refs: [
-                'lex:app.certified.defs#uri',
-                'lex:app.certified.defs#smallBlob',
-              ],
-              description:
-                'The location of where the work was performed as a URI or blob.',
-            },
-            name: {
-              type: 'string',
-              description: 'Optional name for this location',
-              maxLength: 1000,
-              maxGraphemes: 100,
-            },
-            description: {
-              type: 'string',
-              description: 'Optional description for this location',
-              maxLength: 2000,
-              maxGraphemes: 500,
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this record was originally created',
-            },
-          },
-        },
-      },
-    },
-  },
-  ComAtprotoRepoStrongRef: {
-    lexicon: 1,
-    id: 'com.atproto.repo.strongRef',
-    description: 'A URI with a content-hash fingerprint.',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['uri', 'cid'],
-        properties: {
-          uri: {
-            type: 'string',
-            format: 'at-uri',
-          },
-          cid: {
-            type: 'string',
-            format: 'cid',
-          },
-        },
-      },
-    },
-  },
-  OrgHypercertsClaim: {
-    lexicon: 1,
-    id: 'org.hypercerts.claim',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'A hypercert record tracking impact work.',
-        key: 'any',
-        record: {
-          type: 'object',
-          required: [
-            'title',
-            'shortDescription',
-            'createdAt',
-            'workScope',
-            'workTimeFrameFrom',
-            'workTimeFrameTo',
-          ],
-          properties: {
-            title: {
-              type: 'string',
-              description: 'Title of the hypercert',
-              maxLength: 256,
-            },
-            shortDescription: {
-              type: 'string',
-              description: 'Short blurb of the impact work done.',
-              maxLength: 3000,
-              maxGraphemes: 300,
-            },
-            description: {
-              type: 'string',
-              description:
-                'Optional longer description of the impact work done.',
-              maxLength: 30000,
-              maxGraphemes: 3000,
-            },
-            image: {
-              type: 'union',
-              refs: [
-                'lex:app.certified.defs#uri',
-                'lex:app.certified.defs#smallBlob',
-              ],
-              description:
-                'The hypercert visual representation as a URI or blob',
-            },
-            workScope: {
-              type: 'string',
-              description: 'Scope of the work performed',
-              maxLength: 5000,
-              maxGraphemes: 1000,
-            },
-            workTimeFrameFrom: {
-              type: 'string',
-              format: 'datetime',
-              description: 'When the work began',
-            },
-            workTimeFrameTo: {
-              type: 'string',
-              format: 'datetime',
-              description: 'When the work ended',
-            },
-            evidence: {
-              type: 'array',
-              description:
-                'Supporting evidence, documentation, or external data URIs',
-              items: {
-                type: 'ref',
-                ref: 'lex:com.atproto.repo.strongRef',
-                description:
-                  'A strong reference to the evidence that supports this impact claim. The record referenced must conform with the org.hypercerts.claim.evidence lexicon',
-              },
-              maxLength: 100,
-            },
-            contributions: {
-              type: 'array',
-              description:
-                'A strong reference to the contributions done to create the impact in the hypercerts. The record referenced must conform with the lexicon org.hypercerts.claim.contributions',
-              items: {
-                type: 'ref',
-                ref: 'lex:com.atproto.repo.strongRef',
-              },
-            },
-            rights: {
-              type: 'ref',
-              ref: 'lex:com.atproto.repo.strongRef',
-              description:
-                'A strong reference to the rights that this hypercert has. The record referenced must conform with the lexicon org.hypercerts.claim.rights',
-            },
-            location: {
-              type: 'ref',
-              ref: 'lex:com.atproto.repo.strongRef',
-              description:
-                'A strong reference to the location where the work for done hypercert was located. The record referenced must conform with the lexicon org.hypercerts.claim.location',
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this record was originally created',
-            },
-          },
-        },
-      },
-    },
-  },
-  OrgHypercertsClaimContribution: {
-    lexicon: 1,
-    id: 'org.hypercerts.claim.contribution',
-    defs: {
-      main: {
-        type: 'record',
-        description: "A contribution made toward a hypercert's impact.",
-        key: 'any',
-        record: {
-          type: 'object',
-          required: ['hypercert', 'contributors', 'createdAt'],
-          properties: {
-            hypercert: {
-              type: 'ref',
-              ref: 'lex:com.atproto.repo.strongRef',
-              description:
-                'A strong reference to the hypercert this contribution is for. The record referenced must conform with the lexicon org.hypercerts.claim.',
-            },
-            role: {
-              type: 'string',
-              description: 'Role or title of the contributor(s).',
-              maxLength: 100,
-            },
-            contributors: {
-              type: 'array',
-              description:
-                'List of the contributors (names, pseudonyms, or DIDs). If multiple contributors are stored in the same hypercertContribution, then they would have the exact same role.',
-              items: {
-                type: 'string',
-              },
-            },
-            description: {
-              type: 'string',
-              description: 'What the contribution concretely achieved',
-              maxLength: 2000,
-              maxGraphemes: 500,
-            },
-            workTimeframeFrom: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'When this contribution started. This should be a subset of the hypercert timeframe.',
-            },
-            workTimeframeTo: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'When this contribution finished.  This should be a subset of the hypercert timeframe.',
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this record was originally created',
-            },
-          },
-        },
-      },
-    },
-  },
-  OrgHypercertsClaimEvaluation: {
-    lexicon: 1,
-    id: 'org.hypercerts.claim.evaluation',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'An evaluation of a hypercert or other claim',
-        key: 'tid',
-        record: {
-          type: 'object',
-          required: ['subject', 'evaluators', 'summary', 'createdAt'],
-          properties: {
-            subject: {
-              type: 'ref',
-              ref: 'lex:com.atproto.repo.strongRef',
-              description:
-                'A strong reference to the evaluated claim. (e.g measurement, hypercert, contribution, etc)',
-            },
-            evaluators: {
-              type: 'array',
-              description: 'DIDs of the evaluators',
-              items: {
-                type: 'string',
-                format: 'did',
-              },
-              maxLength: 100,
-            },
-            evaluations: {
-              type: 'array',
-              description:
-                'Evaluation data (URIs or blobs) containing detailed reports or methodology',
-              items: {
-                type: 'union',
-                refs: [
-                  'lex:app.certified.defs#uri',
-                  'lex:app.certified.defs#smallBlob',
-                ],
-              },
-              maxLength: 100,
-            },
-            summary: {
-              type: 'string',
-              description: 'Brief evaluation summary',
-              maxLength: 5000,
-              maxGraphemes: 1000,
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this record was originally created',
-            },
-          },
-        },
-      },
-    },
-  },
-  OrgHypercertsClaimEvidence: {
-    lexicon: 1,
-    id: 'org.hypercerts.claim.evidence',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'A piece of evidence supporting a hypercert claim',
-        key: 'any',
-        record: {
-          type: 'object',
-          required: ['content', 'shortDescription', 'createdAt'],
-          properties: {
-            content: {
-              type: 'union',
-              refs: [
-                'lex:app.certified.defs#uri',
-                'lex:app.certified.defs#smallBlob',
-              ],
-              description:
-                'A piece of evidence (URI or blobs) supporting a hypercert claim',
-            },
-            title: {
-              type: 'string',
-              maxLength: 256,
-              description:
-                'Optional title to describe the nature of the evidence',
-            },
-            shortDescription: {
-              type: 'string',
-              maxLength: 3000,
-              maxGraphemes: 300,
-              description:
-                'Short description explaining what this evidence demonstrates or proves',
-            },
-            description: {
-              type: 'string',
-              description:
-                'Optional longer description describing the impact claim evidence.',
-              maxLength: 30000,
-              maxGraphemes: 3000,
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this hypercert claim was originally created',
-            },
-          },
-        },
-      },
-    },
-  },
-  OrgHypercertsClaimMeasurement: {
-    lexicon: 1,
-    id: 'org.hypercerts.claim.measurement',
-    defs: {
-      main: {
-        type: 'record',
-        description: 'External measurement data supporting a hypercert claim',
-        key: 'tid',
-        record: {
-          type: 'object',
-          required: ['hypercert', 'measurers', 'metric', 'value', 'createdAt'],
-          properties: {
-            hypercert: {
-              type: 'ref',
-              ref: 'lex:com.atproto.repo.strongRef',
-              description:
-                'A strong reference to the hypercert that this measurement is for. The record referenced must conform with the lexicon org.hypercerts.claim.',
-            },
-            measurers: {
-              type: 'array',
-              description:
-                'DIDs of the entity (or entities) that measured this data',
-              items: {
-                type: 'string',
-                format: 'did',
-              },
-              maxLength: 100,
-            },
-            metric: {
-              type: 'string',
-              description: 'The metric being measured',
-              maxLength: 500,
-            },
-            value: {
-              type: 'string',
-              description: 'The measured value',
-              maxLength: 500,
-            },
-            measurementMethodURI: {
-              type: 'string',
-              format: 'uri',
-              description:
-                'URI to methodology documentation, standard protocol, or measurement procedure',
-            },
-            evidenceURI: {
-              type: 'array',
-              description: 'URIs to supporting evidence or data',
-              items: {
-                type: 'string',
-                format: 'uri',
-              },
-              maxLength: 50,
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this record was originally created',
-            },
-          },
-        },
-      },
-    },
-  },
-  OrgHypercertsClaimRights: {
-    lexicon: 1,
-    id: 'org.hypercerts.claim.rights',
-    defs: {
-      main: {
-        type: 'record',
-        description:
-          'Describes the rights that a user has with a hypercert, such as whether it can be sold, transferred, and under what conditions.',
-        key: 'any',
-        record: {
-          type: 'object',
-          required: [
-            'rightsName',
-            'rightsType',
-            'rightsDescription',
-            'createdAt',
-          ],
-          properties: {
-            rightsName: {
-              type: 'string',
-              description: 'Full name of the rights',
-              maxLength: 100,
-            },
-            rightsType: {
-              type: 'string',
-              description: 'Short rights identifier for easier search',
-              maxLength: 10,
-            },
-            rightsDescription: {
-              type: 'string',
-              description: 'Description of the rights of this hypercert',
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this record was originally created',
-            },
-          },
-        },
-      },
-    },
-  },
-  OrgHypercertsCollection: {
-    lexicon: 1,
-    id: 'org.hypercerts.collection',
-    defs: {
-      main: {
-        type: 'record',
-        description:
-          'A collection/group of hypercerts that have a specific property.',
-        key: 'tid',
-        record: {
-          type: 'object',
-          required: ['title', 'claims', 'createdAt'],
-          properties: {
-            title: {
-              type: 'string',
-              description: 'The title of this collection',
-              maxLength: 800,
-              maxGraphemes: 80,
-            },
-            shortDescription: {
-              type: 'string',
-              maxLength: 3000,
-              maxGraphemes: 300,
-              description: 'A short description of this collection',
-            },
-            coverPhoto: {
-              type: 'union',
-              refs: [
-                'lex:app.certified.defs#uri',
-                'lex:app.certified.defs#smallBlob',
-              ],
-              description:
-                'The cover photo of this collection (either in URI format or in a blob).',
-            },
-            claims: {
-              type: 'array',
-              description:
-                'Array of claims with their associated weights in this collection',
-              items: {
-                type: 'ref',
-                ref: 'lex:org.hypercerts.collection#claimItem',
-              },
-            },
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-              description:
-                'Client-declared timestamp when this record was originally created',
-            },
-          },
-        },
-      },
-      claimItem: {
-        type: 'object',
-        required: ['claim', 'weight'],
-        properties: {
-          claim: {
-            type: 'ref',
-            ref: 'lex:com.atproto.repo.strongRef',
-            description:
-              'A strong reference to a hypercert claim record. This claim must conform to the lexicon org.hypercerts.claim.record',
-          },
-          weight: {
-            type: 'string',
-            description:
-              'The weight/importance of this hypercert claim in the collection (a percentage from 0-100, stored as a string to avoid float precision issues). The total claim weights should add up to 100.',
-          },
-        },
-      },
-    },
-  },
-} as const satisfies Record<string, LexiconDoc>
-export const schemas = Object.values(schemaDict) satisfies LexiconDoc[]
-export const lexicons: Lexicons = new Lexicons(schemas)
-
-export function validate<T extends { $type: string }>(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType: true,
-): ValidationResult<T>
-export function validate<T extends { $type?: string }>(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType?: false,
-): ValidationResult<T>
-export function validate(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType?: boolean,
-): ValidationResult {
-  return (requiredType ? is$typed : maybe$typed)(v, id, hash)
-    ? lexicons.validate(`${id}#${hash}`, v)
-    : {
-        success: false,
-        error: new ValidationError(
-          `Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`,
-        ),
-      }
-}
-
-export const ids = {
-  AppCertifiedDefs: 'app.certified.defs',
-  AppCertifiedLocation: 'app.certified.location',
-  ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
-  OrgHypercertsClaim: 'org.hypercerts.claim',
-  OrgHypercertsClaimContribution: 'org.hypercerts.claim.contribution',
-  OrgHypercertsClaimEvaluation: 'org.hypercerts.claim.evaluation',
-  OrgHypercertsClaimEvidence: 'org.hypercerts.claim.evidence',
-  OrgHypercertsClaimMeasurement: 'org.hypercerts.claim.measurement',
-  OrgHypercertsClaimRights: 'org.hypercerts.claim.rights',
-  OrgHypercertsCollection: 'org.hypercerts.collection',
-} as const

package/src/types/app/certified/defs.ts

@@ -1,18 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../lexicons'
-import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'app.certified.defs'
-
-/** URI to external data */
-export type Uri = string
-/** Blob to external data (up to 10MB) */
-export type SmallBlob = BlobRef
-/** Blob to external data (up to 100MB) */
-export type LargeBlob = BlobRef

package/src/types/app/certified/location.ts

@@ -1,49 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../lexicons'
-import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
-import type * as AppCertifiedDefs from './defs.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'app.certified.location'
-
-export interface Main {
-  $type: 'app.certified.location'
-  /** The version of the Location Protocol */
-  lpVersion: string
-  /** The Spatial Reference System URI (e.g., http://www.opengis.net/def/crs/OGC/1.3/CRS84) that defines the coordinate system. */
-  srs: string
-  /** An identifier for the format of the location data (e.g., coordinate-decimal, geojson-point) */
-  locationType: 'coordinate-decimal' | 'geojson-point' | (string & {})
-  location:
-    | $Typed<AppCertifiedDefs.Uri>
-    | $Typed<AppCertifiedDefs.SmallBlob>
-    | { $type: string }
-  /** Optional name for this location */
-  name?: string
-  /** Optional description for this location */
-  description?: string
-  /** Client-declared timestamp when this record was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}

package/src/types/com/atproto/repo/strongRef.ts

@@ -1,31 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.strongRef'
-
-export interface Main {
-  $type?: 'com.atproto.repo.strongRef'
-  uri: string
-  cid: string
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}

package/src/types/org/hypercerts/claim/contribution.ts

@@ -1,50 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'org.hypercerts.claim.contribution'
-
-export interface Main {
-  $type: 'org.hypercerts.claim.contribution'
-  hypercert: ComAtprotoRepoStrongRef.Main
-  /** Role or title of the contributor(s). */
-  role?: string
-  /** List of the contributors (names, pseudonyms, or DIDs). If multiple contributors are stored in the same hypercertContribution, then they would have the exact same role. */
-  contributors: string[]
-  /** What the contribution concretely achieved */
-  description?: string
-  /** When this contribution started. This should be a subset of the hypercert timeframe. */
-  workTimeframeFrom?: string
-  /** When this contribution finished.  This should be a subset of the hypercert timeframe. */
-  workTimeframeTo?: string
-  /** Client-declared timestamp when this record was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}

package/src/types/org/hypercerts/claim/evaluation.ts

@@ -1,51 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
-import type * as AppCertifiedDefs from '../../../app/certified/defs.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'org.hypercerts.claim.evaluation'
-
-export interface Main {
-  $type: 'org.hypercerts.claim.evaluation'
-  subject: ComAtprotoRepoStrongRef.Main
-  /** DIDs of the evaluators */
-  evaluators: string[]
-  /** Evaluation data (URIs or blobs) containing detailed reports or methodology */
-  evaluations?: (
-    | $Typed<AppCertifiedDefs.Uri>
-    | $Typed<AppCertifiedDefs.SmallBlob>
-    | { $type: string }
-  )[]
-  /** Brief evaluation summary */
-  summary: string
-  /** Client-declared timestamp when this record was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}

package/src/types/org/hypercerts/claim/evidence.ts

@@ -1,49 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as AppCertifiedDefs from '../../../app/certified/defs.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'org.hypercerts.claim.evidence'
-
-export interface Main {
-  $type: 'org.hypercerts.claim.evidence'
-  content:
-    | $Typed<AppCertifiedDefs.Uri>
-    | $Typed<AppCertifiedDefs.SmallBlob>
-    | { $type: string }
-  /** Optional title to describe the nature of the evidence */
-  title?: string
-  /** Short description explaining what this evidence demonstrates or proves */
-  shortDescription: string
-  /** Optional longer description describing the impact claim evidence. */
-  description?: string
-  /** Client-declared timestamp when this hypercert claim was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}

package/src/types/org/hypercerts/claim/measurement.ts

@@ -1,50 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'org.hypercerts.claim.measurement'
-
-export interface Main {
-  $type: 'org.hypercerts.claim.measurement'
-  hypercert: ComAtprotoRepoStrongRef.Main
-  /** DIDs of the entity (or entities) that measured this data */
-  measurers: string[]
-  /** The metric being measured */
-  metric: string
-  /** The measured value */
-  value: string
-  /** URI to methodology documentation, standard protocol, or measurement procedure */
-  measurementMethodURI?: string
-  /** URIs to supporting evidence or data */
-  evidenceURI?: string[]
-  /** Client-declared timestamp when this record was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}

package/src/types/org/hypercerts/claim/rights.ts

@@ -1,44 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'org.hypercerts.claim.rights'
-
-export interface Main {
-  $type: 'org.hypercerts.claim.rights'
-  /** Full name of the rights */
-  rightsName: string
-  /** Short rights identifier for easier search */
-  rightsType: string
-  /** Description of the rights of this hypercert */
-  rightsDescription: string
-  /** Client-declared timestamp when this record was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}

package/src/types/org/hypercerts/claim.ts

@@ -1,58 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../lexicons'
-import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
-import type * as AppCertifiedDefs from '../../app/certified/defs.js'
-import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'org.hypercerts.claim'
-
-export interface Main {
-  $type: 'org.hypercerts.claim'
-  /** Title of the hypercert */
-  title: string
-  /** Short blurb of the impact work done. */
-  shortDescription: string
-  /** Optional longer description of the impact work done. */
-  description?: string
-  image?:
-    | $Typed<AppCertifiedDefs.Uri>
-    | $Typed<AppCertifiedDefs.SmallBlob>
-    | { $type: string }
-  /** Scope of the work performed */
-  workScope: string
-  /** When the work began */
-  workTimeFrameFrom: string
-  /** When the work ended */
-  workTimeFrameTo: string
-  /** Supporting evidence, documentation, or external data URIs */
-  evidence?: ComAtprotoRepoStrongRef.Main[]
-  /** A strong reference to the contributions done to create the impact in the hypercerts. The record referenced must conform with the lexicon org.hypercerts.claim.contributions */
-  contributions?: ComAtprotoRepoStrongRef.Main[]
-  rights?: ComAtprotoRepoStrongRef.Main
-  location?: ComAtprotoRepoStrongRef.Main
-  /** Client-declared timestamp when this record was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}

package/src/types/org/hypercerts/collection.ts

@@ -1,63 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../lexicons'
-import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
-import type * as AppCertifiedDefs from '../../app/certified/defs.js'
-import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'org.hypercerts.collection'
-
-export interface Main {
-  $type: 'org.hypercerts.collection'
-  /** The title of this collection */
-  title: string
-  /** A short description of this collection */
-  shortDescription?: string
-  coverPhoto?:
-    | $Typed<AppCertifiedDefs.Uri>
-    | $Typed<AppCertifiedDefs.SmallBlob>
-    | { $type: string }
-  /** Array of claims with their associated weights in this collection */
-  claims: ClaimItem[]
-  /** Client-declared timestamp when this record was originally created */
-  createdAt: string
-  [k: string]: unknown
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain, true)
-}
-
-export {
-  type Main as Record,
-  isMain as isRecord,
-  validateMain as validateRecord,
-}
-
-export interface ClaimItem {
-  $type?: 'org.hypercerts.collection#claimItem'
-  claim: ComAtprotoRepoStrongRef.Main
-  /** The weight/importance of this hypercert claim in the collection (a percentage from 0-100, stored as a string to avoid float precision issues). The total claim weights should add up to 100. */
-  weight: string
-}
-
-const hashClaimItem = 'claimItem'
-
-export function isClaimItem<V>(v: V) {
-  return is$typed(v, id, hashClaimItem)
-}
-
-export function validateClaimItem<V>(v: V) {
-  return validate<ClaimItem & V>(v, id, hashClaimItem)
-}

package/src/util.ts

@@ -1,82 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-
-import { type ValidationResult } from '@atproto/lexicon'
-
-export type OmitKey<T, K extends keyof T> = {
-  [K2 in keyof T as K2 extends K ? never : K2]: T[K2]
-}
-
-export type $Typed<V, T extends string = string> = V & { $type: T }
-export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>
-
-export type $Type<Id extends string, Hash extends string> = Hash extends 'main'
-  ? Id
-  : `${Id}#${Hash}`
-
-function isObject<V>(v: V): v is V & object {
-  return v != null && typeof v === 'object'
-}
-
-function is$type<Id extends string, Hash extends string>(
-  $type: unknown,
-  id: Id,
-  hash: Hash,
-): $type is $Type<Id, Hash> {
-  return hash === 'main'
-    ? $type === id
-    : // $type === `${id}#${hash}`
-      typeof $type === 'string' &&
-        $type.length === id.length + 1 + hash.length &&
-        $type.charCodeAt(id.length) === 35 /* '#' */ &&
-        $type.startsWith(id) &&
-        $type.endsWith(hash)
-}
-
-export type $TypedObject<
-  V,
-  Id extends string,
-  Hash extends string,
-> = V extends {
-  $type: $Type<Id, Hash>
-}
-  ? V
-  : V extends { $type?: string }
-    ? V extends { $type?: infer T extends $Type<Id, Hash> }
-      ? V & { $type: T }
-      : never
-    : V & { $type: $Type<Id, Hash> }
-
-export function is$typed<V, Id extends string, Hash extends string>(
-  v: V,
-  id: Id,
-  hash: Hash,
-): v is $TypedObject<V, Id, Hash> {
-  return isObject(v) && '$type' in v && is$type(v.$type, id, hash)
-}
-
-export function maybe$typed<V, Id extends string, Hash extends string>(
-  v: V,
-  id: Id,
-  hash: Hash,
-): v is V & object & { $type?: $Type<Id, Hash> } {
-  return (
-    isObject(v) &&
-    ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true)
-  )
-}
-
-export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>
-export type ValidatorParam<V extends Validator> =
-  V extends Validator<infer R> ? R : never
-
-/**
- * Utility function that allows to convert a "validate*" utility function into a
- * type predicate.
- */
-export function asPredicate<V extends Validator>(validate: V) {
-  return function <T>(v: T): v is T & ValidatorParam<V> {
-    return validate(v).success
-  }
-}