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

package/types/types/org/hypercerts/claim/rights.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 '../defs.js'
+
+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
+  attachment?:
+    | $Typed<OrgHypercertsDefs.Uri>
+    | $Typed<OrgHypercertsDefs.SmallBlob>
+    | { $type: 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/defs.ts

@@ -0,0 +1,96 @@
+/**
+ * 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.defs'
+
+/** Object containing a URI to external data */
+export interface Uri {
+  $type?: 'org.hypercerts.defs#uri'
+  /** URI to external data */
+  uri: string
+}
+
+const hashUri = 'uri'
+
+export function isUri<V>(v: V) {
+  return is$typed(v, id, hashUri)
+}
+
+export function validateUri<V>(v: V) {
+  return validate<Uri & V>(v, id, hashUri)
+}
+
+/** Object containing a blob to external data */
+export interface SmallBlob {
+  $type?: 'org.hypercerts.defs#smallBlob'
+  /** Blob to external data (up to 10MB) */
+  blob: BlobRef
+}
+
+const hashSmallBlob = 'smallBlob'
+
+export function isSmallBlob<V>(v: V) {
+  return is$typed(v, id, hashSmallBlob)
+}
+
+export function validateSmallBlob<V>(v: V) {
+  return validate<SmallBlob & V>(v, id, hashSmallBlob)
+}
+
+/** Object containing a blob to external data */
+export interface LargeBlob {
+  $type?: 'org.hypercerts.defs#largeBlob'
+  /** Blob to external data (up to 100MB) */
+  blob: BlobRef
+}
+
+const hashLargeBlob = 'largeBlob'
+
+export function isLargeBlob<V>(v: V) {
+  return is$typed(v, id, hashLargeBlob)
+}
+
+export function validateLargeBlob<V>(v: V) {
+  return validate<LargeBlob & V>(v, id, hashLargeBlob)
+}
+
+/** Object containing a small image */
+export interface SmallImage {
+  $type?: 'org.hypercerts.defs#smallImage'
+  /** Image (up to 5MB) */
+  image: BlobRef
+}
+
+const hashSmallImage = 'smallImage'
+
+export function isSmallImage<V>(v: V) {
+  return is$typed(v, id, hashSmallImage)
+}
+
+export function validateSmallImage<V>(v: V) {
+  return validate<SmallImage & V>(v, id, hashSmallImage)
+}
+
+/** Object containing a large image */
+export interface LargeImage {
+  $type?: 'org.hypercerts.defs#largeImage'
+  /** Image (up to 10MB) */
+  image: BlobRef
+}
+
+const hashLargeImage = 'largeImage'
+
+export function isLargeImage<V>(v: V) {
+  return is$typed(v, id, hashLargeImage)
+}
+
+export function validateLargeImage<V>(v: V) {
+  return validate<LargeImage & V>(v, id, hashLargeImage)
+}

package/types/types/org/hypercerts/funding/receipt.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'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'org.hypercerts.funding.receipt'
+
+export interface Main {
+  $type: 'org.hypercerts.funding.receipt'
+  from: AppCertifiedDefs.Did
+  /** The recipient of the funds. Can be identified by DID or a clear-text name. */
+  to: string
+  /** Amount of funding received. */
+  amount: string
+  /** Currency of the payment (e.g. EUR, USD, ETH). */
+  currency: string
+  /** How the funds were transferred (e.g. bank_transfer, credit_card, onchain, cash, check, payment_processor). */
+  paymentRail?: string
+  /** Optional network within the payment rail (e.g. arbitrum, ethereum, sepa, visa, paypal). */
+  paymentNetwork?: string
+  /** Identifier of the underlying payment transaction (e.g. bank reference, onchain transaction hash, or processor-specific ID). Use paymentNetwork to specify the network where applicable. */
+  transactionId?: string
+  /** Optional reference to the activity, project, or organization this funding relates to. */
+  for?: string
+  /** Optional notes or additional context for this funding receipt. */
+  notes?: string
+  /** Timestamp when the payment occurred. */
+  occurredAt?: string
+  /** Client-declared timestamp when this receipt record was 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/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
+  }
+}