@hypercerts-org/lexicon 0.8.0-beta.0 → 0.10.0-beta.0

package/types/types/app/certified/badge/award.ts

@@ -0,0 +1,48 @@
+/**
+ * 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 AppCertifiedBadgeDefinition from './definition.js'
+import type * as AppCertifiedDefs from '../defs.js'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.certified.badge.award'
+
+export interface Main {
+  $type: 'app.certified.badge.award'
+  badge: AppCertifiedBadgeDefinition.Main
+  subject:
+    | $Typed<AppCertifiedDefs.Did>
+    | $Typed<ComAtprotoRepoStrongRef.Main>
+    | { $type: string }
+  /** Optional statement explaining the reason for this badge award. */
+  note?: 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/types/types/app/certified/badge/definition.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 '../defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.certified.badge.definition'
+
+export interface Main {
+  $type: 'app.certified.badge.definition'
+  /** Category of the badge (e.g. endorsement, participation, affiliation). */
+  badgeType: string
+  /** Human-readable title of the badge. */
+  title: string
+  /** Icon representing the badge, stored as a blob for compact visual display. */
+  icon: BlobRef
+  /** Optional short statement describing what the badge represents. */
+  description?: string
+  /** Optional allowlist of DIDs allowed to issue this badge. If omitted, anyone may issue it. */
+  allowedIssuers?: AppCertifiedDefs.Did[]
+  /** 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/types/types/app/certified/badge/response.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'
+import type * as AppCertifiedBadgeAward from './award.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.certified.badge.response'
+
+export interface Main {
+  $type: 'app.certified.badge.response'
+  badgeAward: AppCertifiedBadgeAward.Main
+  /** The recipient’s response for the badge (accepted or rejected). */
+  response: 'accepted' | 'rejected'
+  /** Optional relative weight for accepted badges, assigned by the recipient. */
+  weight?: 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/types/types/app/certified/defs.ts

@@ -0,0 +1,14 @@
+/**
+ * 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'
+
+/** A Decentralized Identifier (DID) string. */
+export type Did = string

package/types/types/app/certified/location.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 OrgHypercertsDefs from '../../org/hypercerts/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<OrgHypercertsDefs.Uri>
+    | $Typed<OrgHypercertsDefs.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/types/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/types/types/org/hypercerts/claim/activity.ts

@@ -0,0 +1,99 @@
+/**
+ * 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 OrgHypercertsDefs from '../defs.js'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'org.hypercerts.claim.activity'
+
+export interface Main {
+  $type: 'org.hypercerts.claim.activity'
+  /** 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<OrgHypercertsDefs.Uri>
+    | $Typed<OrgHypercertsDefs.SmallImage>
+    | { $type: string }
+  workScope?: WorkScope
+  /** When the work began */
+  startDate: string
+  /** When the work ended */
+  endDate: string
+  /** 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.contribution. */
+  contributions?: ComAtprotoRepoStrongRef.Main[]
+  rights?: ComAtprotoRepoStrongRef.Main
+  location?: ComAtprotoRepoStrongRef.Main
+  /** A reference (AT-URI) to the project record that this activity is part of. The record referenced must conform with the lexicon org.hypercerts.claim.project. This activity must also be referenced by the project, establishing a bidirectional link. */
+  project?: 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,
+}
+
+/** Logical scope of the work using label-based conditions. All labels in `withinAllOf` must apply; at least one label in `withinAnyOf` must apply if provided; no label in `withinNoneOf` may apply. */
+export interface WorkScope {
+  $type?: 'org.hypercerts.claim.activity#workScope'
+  /** Labels that MUST all hold for the scope to apply. */
+  withinAllOf?: string[]
+  /** Labels of which AT LEAST ONE must hold (optional). If omitted or empty, imposes no additional condition. */
+  withinAnyOf?: string[]
+  /** Labels that MUST NOT hold for the scope to apply. */
+  withinNoneOf?: string[]
+}
+
+const hashWorkScope = 'workScope'
+
+export function isWorkScope<V>(v: V) {
+  return is$typed(v, id, hashWorkScope)
+}
+
+export function validateWorkScope<V>(v: V) {
+  return validate<WorkScope & V>(v, id, hashWorkScope)
+}
+
+export interface ActivityWeight {
+  $type?: 'org.hypercerts.claim.activity#activityWeight'
+  activity: ComAtprotoRepoStrongRef.Main
+  /** The relative weight/importance of this hypercert activity (stored as a string to avoid float precision issues). Weights can be any positive numeric values and do not need to sum to a specific total; normalization can be performed by the consuming application as needed. */
+  weight: string
+}
+
+const hashActivityWeight = 'activityWeight'
+
+export function isActivityWeight<V>(v: V) {
+  return is$typed(v, id, hashActivityWeight)
+}
+
+export function validateActivityWeight<V>(v: V) {
+  return validate<ActivityWeight & V>(v, id, hashActivityWeight)
+}

package/types/types/org/hypercerts/claim/collection.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 OrgHypercertsClaimActivity from './activity.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'org.hypercerts.claim.collection'
+
+export interface Main {
+  $type: 'org.hypercerts.claim.collection'
+  /** The title of this collection */
+  title: string
+  /** A short description of this collection */
+  shortDescription?: string
+  /** Primary avatar image representing this collection across apps and views; typically a square image. */
+  avatar?: BlobRef
+  /** The cover photo of this collection. */
+  coverPhoto?: BlobRef
+  /** Array of activities with their associated weights in this collection */
+  activities: OrgHypercertsClaimActivity.ActivityWeight[]
+  /** 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/types/types/org/hypercerts/claim/contribution.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.contribution'
+
+export interface Main {
+  $type: 'org.hypercerts.claim.contribution'
+  /** 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. */
+  startDate?: string
+  /** When this contribution finished.  This should be a subset of the hypercert timeframe. */
+  endDate?: 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/types/types/org/hypercerts/claim/evaluation.ts

@@ -0,0 +1,77 @@
+/**
+ * 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'
+import type * as OrgHypercertsDefs from '../defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'org.hypercerts.claim.evaluation'
+
+/** Overall score for an evaluation on a numeric scale. */
+export interface Score {
+  $type?: 'org.hypercerts.claim.evaluation#score'
+  /** Minimum value of the scale, e.g. 0 or 1. */
+  min: number
+  /** Maximum value of the scale, e.g. 5 or 10. */
+  max: number
+  /** Score within the inclusive range [min, max]. */
+  value: number
+}
+
+const hashScore = 'score'
+
+export function isScore<V>(v: V) {
+  return is$typed(v, id, hashScore)
+}
+
+export function validateScore<V>(v: V) {
+  return validate<Score & V>(v, id, hashScore)
+}
+
+export interface Main {
+  $type: 'org.hypercerts.claim.evaluation'
+  subject?: ComAtprotoRepoStrongRef.Main
+  /** DIDs of the evaluators */
+  evaluators: AppCertifiedDefs.Did[]
+  /** Evaluation data (URIs or blobs) containing detailed reports or methodology */
+  content?: (
+    | $Typed<OrgHypercertsDefs.Uri>
+    | $Typed<OrgHypercertsDefs.SmallBlob>
+    | { $type: string }
+  )[]
+  /** Optional references to the measurements that contributed to this evaluation. The record(s) referenced must conform with the lexicon org.hypercerts.claim.measurement */
+  measurements?: ComAtprotoRepoStrongRef.Main[]
+  /** Brief evaluation summary */
+  summary: string
+  score?: Score
+  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/types/types/org/hypercerts/claim/evidence.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 OrgHypercertsDefs from '../defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'org.hypercerts.claim.evidence'
+
+export interface Main {
+  $type: 'org.hypercerts.claim.evidence'
+  subject?: ComAtprotoRepoStrongRef.Main
+  content:
+    | $Typed<OrgHypercertsDefs.Uri>
+    | $Typed<OrgHypercertsDefs.SmallBlob>
+    | { $type: string }
+  /** Title to describe the nature of the evidence. */
+  title: string
+  /** Short description explaining what this evidence shows. */
+  shortDescription?: string
+  /** Longer description describing the evidence in more detail. */
+  description?: string
+  /** How this evidence relates to the subject. */
+  relationType?: 'supports' | 'challenges' | 'clarifies' | (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/types/types/org/hypercerts/claim/measurement.ts

@@ -0,0 +1,54 @@
+/**
+ * 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.measurement'
+
+export interface Main {
+  $type: 'org.hypercerts.claim.measurement'
+  subject?: ComAtprotoRepoStrongRef.Main
+  /** DIDs of the entity (or entities) that measured this data */
+  measurers: AppCertifiedDefs.Did[]
+  /** The metric being measured */
+  metric: string
+  /** The measured value */
+  value: string
+  /** Short identifier for the measurement methodology */
+  methodType?: string
+  /** URI to methodology documentation, standard protocol, or measurement procedure */
+  methodURI?: string
+  /** URIs to related evidence or underlying data (e.g. org.hypercerts.claim.evidence records or raw datasets) */
+  evidenceURI?: string[]
+  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/types/types/org/hypercerts/claim/project.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 PubLeafletPagesLinearDocument from '../../../pub/leaflet/pages/linearDocument.js'
+import type * as OrgHypercertsClaimActivity from './activity.js'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'org.hypercerts.claim.project'
+
+export interface Main {
+  $type: 'org.hypercerts.claim.project'
+  /** Title of this project */
+  title: string
+  /** Short summary of this project, suitable for previews and list views. */
+  shortDescription: string
+  description?: PubLeafletPagesLinearDocument.Main
+  /** Primary avatar image representing this project across apps and views; typically a square logo or project identity image. */
+  avatar?: BlobRef
+  /** The cover photo of this project. */
+  coverPhoto?: BlobRef
+  /** Array of activities with their associated weights in this project */
+  activities?: OrgHypercertsClaimActivity.ActivityWeight[]
+  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,
+}