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

package/types/types/org/hypercerts/claim/rights.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 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

@@ -1,96 +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.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

@@ -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'
-
-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

@@ -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
-  }
-}