@atproto/api 0.13.21 → 0.14.0-next.1

package/src/client/types/com/atproto/label/subscribeLabels.ts

@@ -3,43 +3,55 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
-import * as ComAtprotoLabelDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoLabelDefs from './defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.label.subscribeLabels'
 
 export interface Labels {
+  $type?: $Type<'com.atproto.label.subscribeLabels', 'labels'>
   seq: number
   labels: ComAtprotoLabelDefs.Label[]
-  [k: string]: unknown
 }
 
-export function isLabels(v: unknown): v is Labels {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.subscribeLabels#labels'
-  )
+const hashLabels = 'labels'
+
+export function isLabels<V>(v: V) {
+  return is$typed(v, id, hashLabels)
+}
+
+export function validateLabels<V>(v: V) {
+  return validate<Labels & V>(v, id, hashLabels)
 }
 
-export function validateLabels(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.subscribeLabels#labels', v)
+export function isValidLabels<V>(v: V) {
+  return isValid<Labels>(v, id, hashLabels)
 }
 
 export interface Info {
+  $type?: $Type<'com.atproto.label.subscribeLabels', 'info'>
   name: 'OutdatedCursor' | (string & {})
   message?: string
-  [k: string]: unknown
 }
 
-export function isInfo(v: unknown): v is Info {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.label.subscribeLabels#info'
-  )
+const hashInfo = 'info'
+
+export function isInfo<V>(v: V) {
+  return is$typed(v, id, hashInfo)
+}
+
+export function validateInfo<V>(v: V) {
+  return validate<Info & V>(v, id, hashInfo)
 }
 
-export function validateInfo(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.label.subscribeLabels#info', v)
+export function isValidInfo<V>(v: V) {
+  return isValid<Info>(v, id, hashInfo)
 }

package/src/client/types/com/atproto/moderation/createReport.ts

@@ -3,12 +3,20 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
-import * as ComAtprotoModerationDefs from './defs'
-import * as ComAtprotoAdminDefs from '../admin/defs'
-import * as ComAtprotoRepoStrongRef from '../repo/strongRef'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoModerationDefs from './defs'
+import type * as ComAtprotoAdminDefs from '../admin/defs'
+import type * as ComAtprotoRepoStrongRef from '../repo/strongRef'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.moderation.createReport'
 
 export interface QueryParams {}
 
@@ -17,10 +25,9 @@ export interface InputSchema {
   /** Additional context about the content and violation. */
   reason?: string
   subject:
-    | ComAtprotoAdminDefs.RepoRef
-    | ComAtprotoRepoStrongRef.Main
-    | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+    | $Typed<ComAtprotoAdminDefs.RepoRef>
+    | $Typed<ComAtprotoRepoStrongRef.Main>
+    | { $type: string }
 }
 
 export interface OutputSchema {
@@ -28,12 +35,11 @@ export interface OutputSchema {
   reasonType: ComAtprotoModerationDefs.ReasonType
   reason?: string
   subject:
-    | ComAtprotoAdminDefs.RepoRef
-    | ComAtprotoRepoStrongRef.Main
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ComAtprotoAdminDefs.RepoRef>
+    | $Typed<ComAtprotoRepoStrongRef.Main>
+    | { $type: string }
   reportedBy: string
   createdAt: string
-  [k: string]: unknown
 }
 
 export interface CallOptions {

package/src/client/types/com/atproto/moderation/defs.ts

@@ -2,9 +2,17 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.moderation.defs'
 
 export type ReasonType =
   | 'com.atproto.moderation.defs#reasonSpam'
@@ -17,16 +25,16 @@ export type ReasonType =
   | (string & {})
 
 /** Spam: frequent unwanted promotion, replies, mentions */
-export const REASONSPAM = 'com.atproto.moderation.defs#reasonSpam'
+export const REASONSPAM = `${id}#reasonSpam`
 /** Direct violation of server rules, laws, terms of service */
-export const REASONVIOLATION = 'com.atproto.moderation.defs#reasonViolation'
+export const REASONVIOLATION = `${id}#reasonViolation`
 /** Misleading identity, affiliation, or content */
-export const REASONMISLEADING = 'com.atproto.moderation.defs#reasonMisleading'
+export const REASONMISLEADING = `${id}#reasonMisleading`
 /** Unwanted or mislabeled sexual content */
-export const REASONSEXUAL = 'com.atproto.moderation.defs#reasonSexual'
+export const REASONSEXUAL = `${id}#reasonSexual`
 /** Rude, harassing, explicit, or otherwise unwelcoming behavior */
-export const REASONRUDE = 'com.atproto.moderation.defs#reasonRude'
+export const REASONRUDE = `${id}#reasonRude`
 /** Other: reports not falling under another report category */
-export const REASONOTHER = 'com.atproto.moderation.defs#reasonOther'
+export const REASONOTHER = `${id}#reasonOther`
 /** Appeal: appeal a previously taken moderation action */
-export const REASONAPPEAL = 'com.atproto.moderation.defs#reasonAppeal'
+export const REASONAPPEAL = `${id}#reasonAppeal`

package/src/client/types/com/atproto/repo/applyWrites.ts

@@ -3,10 +3,18 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
-import * as ComAtprotoRepoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.applyWrites'
 
 export interface QueryParams {}
 
@@ -15,16 +23,18 @@ export interface InputSchema {
   repo: string
   /** Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons. */
   validate?: boolean
-  writes: (Create | Update | Delete)[]
+  writes: ($Typed<Create> | $Typed<Update> | $Typed<Delete>)[]
   /** If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations. */
   swapCommit?: string
-  [k: string]: unknown
 }
 
 export interface OutputSchema {
   commit?: ComAtprotoRepoDefs.CommitMeta
-  results?: (CreateResult | UpdateResult | DeleteResult)[]
-  [k: string]: unknown
+  results?: (
+    | $Typed<CreateResult>
+    | $Typed<UpdateResult>
+    | $Typed<DeleteResult>
+  )[]
 }
 
 export interface CallOptions {
@@ -56,113 +66,125 @@ export function toKnownErr(e: any) {
 
 /** Operation which creates a new record. */
 export interface Create {
+  $type?: $Type<'com.atproto.repo.applyWrites', 'create'>
   collection: string
   rkey?: string
-  value: {}
-  [k: string]: unknown
+  value: { [_ in string]: unknown }
 }
 
-export function isCreate(v: unknown): v is Create {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#create'
-  )
+const hashCreate = 'create'
+
+export function isCreate<V>(v: V) {
+  return is$typed(v, id, hashCreate)
+}
+
+export function validateCreate<V>(v: V) {
+  return validate<Create & V>(v, id, hashCreate)
 }
 
-export function validateCreate(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#create', v)
+export function isValidCreate<V>(v: V) {
+  return isValid<Create>(v, id, hashCreate)
 }
 
 /** Operation which updates an existing record. */
 export interface Update {
+  $type?: $Type<'com.atproto.repo.applyWrites', 'update'>
   collection: string
   rkey: string
-  value: {}
-  [k: string]: unknown
+  value: { [_ in string]: unknown }
 }
 
-export function isUpdate(v: unknown): v is Update {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#update'
-  )
+const hashUpdate = 'update'
+
+export function isUpdate<V>(v: V) {
+  return is$typed(v, id, hashUpdate)
 }
 
-export function validateUpdate(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#update', v)
+export function validateUpdate<V>(v: V) {
+  return validate<Update & V>(v, id, hashUpdate)
+}
+
+export function isValidUpdate<V>(v: V) {
+  return isValid<Update>(v, id, hashUpdate)
 }
 
 /** Operation which deletes an existing record. */
 export interface Delete {
+  $type?: $Type<'com.atproto.repo.applyWrites', 'delete'>
   collection: string
   rkey: string
-  [k: string]: unknown
 }
 
-export function isDelete(v: unknown): v is Delete {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#delete'
-  )
+const hashDelete = 'delete'
+
+export function isDelete<V>(v: V) {
+  return is$typed(v, id, hashDelete)
+}
+
+export function validateDelete<V>(v: V) {
+  return validate<Delete & V>(v, id, hashDelete)
 }
 
-export function validateDelete(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#delete', v)
+export function isValidDelete<V>(v: V) {
+  return isValid<Delete>(v, id, hashDelete)
 }
 
 export interface CreateResult {
+  $type?: $Type<'com.atproto.repo.applyWrites', 'createResult'>
   uri: string
   cid: string
   validationStatus?: 'valid' | 'unknown' | (string & {})
-  [k: string]: unknown
 }
 
-export function isCreateResult(v: unknown): v is CreateResult {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#createResult'
-  )
+const hashCreateResult = 'createResult'
+
+export function isCreateResult<V>(v: V) {
+  return is$typed(v, id, hashCreateResult)
+}
+
+export function validateCreateResult<V>(v: V) {
+  return validate<CreateResult & V>(v, id, hashCreateResult)
 }
 
-export function validateCreateResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#createResult', v)
+export function isValidCreateResult<V>(v: V) {
+  return isValid<CreateResult>(v, id, hashCreateResult)
 }
 
 export interface UpdateResult {
+  $type?: $Type<'com.atproto.repo.applyWrites', 'updateResult'>
   uri: string
   cid: string
   validationStatus?: 'valid' | 'unknown' | (string & {})
-  [k: string]: unknown
 }
 
-export function isUpdateResult(v: unknown): v is UpdateResult {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#updateResult'
-  )
+const hashUpdateResult = 'updateResult'
+
+export function isUpdateResult<V>(v: V) {
+  return is$typed(v, id, hashUpdateResult)
 }
 
-export function validateUpdateResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#updateResult', v)
+export function validateUpdateResult<V>(v: V) {
+  return validate<UpdateResult & V>(v, id, hashUpdateResult)
+}
+
+export function isValidUpdateResult<V>(v: V) {
+  return isValid<UpdateResult>(v, id, hashUpdateResult)
 }
 
 export interface DeleteResult {
-  [k: string]: unknown
+  $type?: $Type<'com.atproto.repo.applyWrites', 'deleteResult'>
+}
+
+const hashDeleteResult = 'deleteResult'
+
+export function isDeleteResult<V>(v: V) {
+  return is$typed(v, id, hashDeleteResult)
 }
 
-export function isDeleteResult(v: unknown): v is DeleteResult {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#deleteResult'
-  )
+export function validateDeleteResult<V>(v: V) {
+  return validate<DeleteResult & V>(v, id, hashDeleteResult)
 }
 
-export function validateDeleteResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#deleteResult', v)
+export function isValidDeleteResult<V>(v: V) {
+  return isValid<DeleteResult>(v, id, hashDeleteResult)
 }

package/src/client/types/com/atproto/repo/createRecord.ts

@@ -3,10 +3,18 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
-import * as ComAtprotoRepoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.createRecord'
 
 export interface QueryParams {}
 
@@ -20,10 +28,9 @@ export interface InputSchema {
   /** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. */
   validate?: boolean
   /** The record itself. Must contain a $type field. */
-  record: {}
+  record: { [_ in string]: unknown }
   /** Compare and swap with the previous commit by CID. */
   swapCommit?: string
-  [k: string]: unknown
 }
 
 export interface OutputSchema {
@@ -31,7 +38,6 @@ export interface OutputSchema {
   cid: string
   commit?: ComAtprotoRepoDefs.CommitMeta
   validationStatus?: 'valid' | 'unknown' | (string & {})
-  [k: string]: unknown
 }
 
 export interface CallOptions {

package/src/client/types/com/atproto/repo/defs.ts

@@ -2,24 +2,34 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.defs'
 
 export interface CommitMeta {
+  $type?: $Type<'com.atproto.repo.defs', 'commitMeta'>
   cid: string
   rev: string
-  [k: string]: unknown
 }
 
-export function isCommitMeta(v: unknown): v is CommitMeta {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.defs#commitMeta'
-  )
+const hashCommitMeta = 'commitMeta'
+
+export function isCommitMeta<V>(v: V) {
+  return is$typed(v, id, hashCommitMeta)
+}
+
+export function validateCommitMeta<V>(v: V) {
+  return validate<CommitMeta & V>(v, id, hashCommitMeta)
 }
 
-export function validateCommitMeta(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.defs#commitMeta', v)
+export function isValidCommitMeta<V>(v: V) {
+  return isValid<CommitMeta>(v, id, hashCommitMeta)
 }

package/src/client/types/com/atproto/repo/deleteRecord.ts

@@ -3,10 +3,18 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
-import * as ComAtprotoRepoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.deleteRecord'
 
 export interface QueryParams {}
 
@@ -21,12 +29,10 @@ export interface InputSchema {
   swapRecord?: string
   /** Compare and swap with the previous commit by CID. */
   swapCommit?: string
-  [k: string]: unknown
 }
 
 export interface OutputSchema {
   commit?: ComAtprotoRepoDefs.CommitMeta
-  [k: string]: unknown
 }
 
 export interface CallOptions {

package/src/client/types/com/atproto/repo/describeRepo.ts

@@ -3,9 +3,17 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.describeRepo'
 
 export interface QueryParams {
   /** The handle or DID of the repo. */
@@ -18,12 +26,11 @@ export interface OutputSchema {
   handle: string
   did: string
   /** The complete DID document for this account. */
-  didDoc: {}
+  didDoc: { [_ in string]: unknown }
   /** List of all the collections (NSIDs) for which this repo contains at least one record. */
   collections: string[]
   /** Indicates if handle is currently valid (resolves bi-directionally) */
   handleIsCorrect: boolean
-  [k: string]: unknown
 }
 
 export interface CallOptions {

package/src/client/types/com/atproto/repo/getRecord.ts

@@ -3,9 +3,17 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.getRecord'
 
 export interface QueryParams {
   /** The handle or DID of the repo. */
@@ -23,8 +31,7 @@ export type InputSchema = undefined
 export interface OutputSchema {
   uri: string
   cid?: string
-  value: {}
-  [k: string]: unknown
+  value: { [_ in string]: unknown }
 }
 
 export interface CallOptions {

package/src/client/types/com/atproto/repo/importRepo.ts

@@ -3,9 +3,17 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.importRepo'
 
 export interface QueryParams {}
 

package/src/client/types/com/atproto/repo/listMissingBlobs.ts

@@ -3,9 +3,17 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
+const id = 'com.atproto.repo.listMissingBlobs'
 
 export interface QueryParams {
   limit?: number
@@ -17,7 +25,6 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   blobs: RecordBlob[]
-  [k: string]: unknown
 }
 
 export interface CallOptions {
@@ -36,19 +43,21 @@ export function toKnownErr(e: any) {
 }
 
 export interface RecordBlob {
+  $type?: $Type<'com.atproto.repo.listMissingBlobs', 'recordBlob'>
   cid: string
   recordUri: string
-  [k: string]: unknown
 }
 
-export function isRecordBlob(v: unknown): v is RecordBlob {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.listMissingBlobs#recordBlob'
-  )
+const hashRecordBlob = 'recordBlob'
+
+export function isRecordBlob<V>(v: V) {
+  return is$typed(v, id, hashRecordBlob)
+}
+
+export function validateRecordBlob<V>(v: V) {
+  return validate<RecordBlob & V>(v, id, hashRecordBlob)
 }
 
-export function validateRecordBlob(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.listMissingBlobs#recordBlob', v)
+export function isValidRecordBlob<V>(v: V) {
+  return isValid<RecordBlob>(v, id, hashRecordBlob)
 }