@hypercerts-org/lexicon 0.2.0-beta.0

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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,50 @@
+/**
+ * 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

@@ -0,0 +1,51 @@
+/**
+ * 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

@@ -0,0 +1,49 @@
+/**
+ * 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

@@ -0,0 +1,50 @@
+/**
+ * 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

@@ -0,0 +1,44 @@
+/**
+ * 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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,63 @@
+/**
+ * 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

@@ -0,0 +1,82 @@
+/**
+ * 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
+  }
+}