@atproto/api 0.13.20 → 0.14.0-next.0

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

@@ -2,9 +2,11 @@
  * 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.moderation.defs'
 
 export type ReasonType =
   | 'com.atproto.moderation.defs#reasonSpam'
@@ -17,16 +19,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,11 +3,13 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ComAtprotoRepoDefs from './defs'
 
+const id = 'com.atproto.repo.applyWrites'
+
 export interface QueryParams {}
 
 export interface InputSchema {
@@ -15,16 +17,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 +60,122 @@ 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>(v: V) {
+  return is$typed(v, id, 'create')
 }
 
-export function isCreate(v: unknown): v is Create {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#create'
-  )
+export function validateCreate(v: unknown) {
+  return lexicons.validate(`${id}#create`, v) as ValidationResult<Create>
 }
 
-export function validateCreate(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#create', v)
+export function isValidCreate<V>(v: V): v is V & $Typed<Create> {
+  return isCreate(v) && validateCreate(v).success
 }
 
 /** 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>(v: V) {
+  return is$typed(v, id, 'update')
 }
 
-export function isUpdate(v: unknown): v is Update {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.applyWrites#update'
-  )
+export function validateUpdate(v: unknown) {
+  return lexicons.validate(`${id}#update`, v) as ValidationResult<Update>
 }
 
-export function validateUpdate(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#update', v)
+export function isValidUpdate<V>(v: V): v is V & $Typed<Update> {
+  return isUpdate(v) && validateUpdate(v).success
 }
 
 /** 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'
-  )
+export function isDelete<V>(v: V) {
+  return is$typed(v, id, 'delete')
 }
 
-export function validateDelete(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#delete', v)
+export function validateDelete(v: unknown) {
+  return lexicons.validate(`${id}#delete`, v) as ValidationResult<Delete>
+}
+
+export function isValidDelete<V>(v: V): v is V & $Typed<Delete> {
+  return isDelete(v) && validateDelete(v).success
 }
 
 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'
-  )
+export function isCreateResult<V>(v: V) {
+  return is$typed(v, id, 'createResult')
+}
+
+export function validateCreateResult(v: unknown) {
+  return lexicons.validate(
+    `${id}#createResult`,
+    v,
+  ) as ValidationResult<CreateResult>
 }
 
-export function validateCreateResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#createResult', v)
+export function isValidCreateResult<V>(v: V): v is V & $Typed<CreateResult> {
+  return isCreateResult(v) && validateCreateResult(v).success
 }
 
 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'
-  )
+export function isUpdateResult<V>(v: V) {
+  return is$typed(v, id, 'updateResult')
 }
 
-export function validateUpdateResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#updateResult', v)
+export function validateUpdateResult(v: unknown) {
+  return lexicons.validate(
+    `${id}#updateResult`,
+    v,
+  ) as ValidationResult<UpdateResult>
+}
+
+export function isValidUpdateResult<V>(v: V): v is V & $Typed<UpdateResult> {
+  return isUpdateResult(v) && validateUpdateResult(v).success
 }
 
 export interface DeleteResult {
-  [k: string]: unknown
+  $type?: $Type<'com.atproto.repo.applyWrites', 'deleteResult'>
+}
+
+export function isDeleteResult<V>(v: V) {
+  return is$typed(v, id, 'deleteResult')
 }
 
-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: unknown) {
+  return lexicons.validate(
+    `${id}#deleteResult`,
+    v,
+  ) as ValidationResult<DeleteResult>
 }
 
-export function validateDeleteResult(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.applyWrites#deleteResult', v)
+export function isValidDeleteResult<V>(v: V): v is V & $Typed<DeleteResult> {
+  return isDeleteResult(v) && validateDeleteResult(v).success
 }

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

@@ -3,11 +3,13 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ComAtprotoRepoDefs from './defs'
 
+const id = 'com.atproto.repo.createRecord'
+
 export interface QueryParams {}
 
 export interface InputSchema {
@@ -20,10 +22,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 +32,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,29 @@
  * 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+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'
-  )
+export function isCommitMeta<V>(v: V) {
+  return is$typed(v, id, 'commitMeta')
+}
+
+export function validateCommitMeta(v: unknown) {
+  return lexicons.validate(
+    `${id}#commitMeta`,
+    v,
+  ) as ValidationResult<CommitMeta>
 }
 
-export function validateCommitMeta(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.defs#commitMeta', v)
+export function isValidCommitMeta<V>(v: V): v is V & $Typed<CommitMeta> {
+  return isCommitMeta(v) && validateCommitMeta(v).success
 }

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

@@ -3,11 +3,13 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ComAtprotoRepoDefs from './defs'
 
+const id = 'com.atproto.repo.deleteRecord'
+
 export interface QueryParams {}
 
 export interface InputSchema {
@@ -21,12 +23,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,11 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.repo.describeRepo'
 
 export interface QueryParams {
   /** The handle or DID of the repo. */
@@ -18,12 +20,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,11 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.repo.getRecord'
 
 export interface QueryParams {
   /** The handle or DID of the repo. */
@@ -23,8 +25,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,11 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.repo.importRepo'
 
 export interface QueryParams {}
 

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

@@ -3,9 +3,11 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.repo.listMissingBlobs'
 
 export interface QueryParams {
   limit?: number
@@ -17,7 +19,6 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   blobs: RecordBlob[]
-  [k: string]: unknown
 }
 
 export interface CallOptions {
@@ -36,19 +37,22 @@ 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'
-  )
+export function isRecordBlob<V>(v: V) {
+  return is$typed(v, id, 'recordBlob')
+}
+
+export function validateRecordBlob(v: unknown) {
+  return lexicons.validate(
+    `${id}#recordBlob`,
+    v,
+  ) as ValidationResult<RecordBlob>
 }
 
-export function validateRecordBlob(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.listMissingBlobs#recordBlob', v)
+export function isValidRecordBlob<V>(v: V): v is V & $Typed<RecordBlob> {
+  return isRecordBlob(v) && validateRecordBlob(v).success
 }

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

@@ -3,9 +3,11 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.repo.listRecords'
 
 export interface QueryParams {
   /** The handle or DID of the repo. */
@@ -28,7 +30,6 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   records: Record[]
-  [k: string]: unknown
 }
 
 export interface CallOptions {
@@ -47,20 +48,20 @@ export function toKnownErr(e: any) {
 }
 
 export interface Record {
+  $type?: $Type<'com.atproto.repo.listRecords', 'record'>
   uri: string
   cid: string
-  value: {}
-  [k: string]: unknown
+  value: { [_ in string]: unknown }
+}
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, 'record')
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'com.atproto.repo.listRecords#record'
-  )
+export function validateRecord(v: unknown) {
+  return lexicons.validate(`${id}#record`, v) as ValidationResult<Record>
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.listRecords#record', v)
+export function isValidRecord<V>(v: V): v is V & $Typed<Record> {
+  return isRecord(v) && validateRecord(v).success
 }

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

@@ -3,11 +3,13 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ComAtprotoRepoDefs from './defs'
 
+const id = 'com.atproto.repo.putRecord'
+
 export interface QueryParams {}
 
 export interface InputSchema {
@@ -20,12 +22,11 @@ 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 to write. */
-  record: {}
+  record: { [_ in string]: unknown }
   /** Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation */
   swapRecord?: string | null
   /** Compare and swap with the previous commit by CID. */
   swapCommit?: string
-  [k: string]: unknown
 }
 
 export interface OutputSchema {
@@ -33,7 +34,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/strongRef.ts

@@ -2,25 +2,26 @@
  * 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.repo.strongRef'
 
 export interface Main {
+  $type?: $Type<'com.atproto.repo.strongRef', 'main'>
   uri: string
   cid: string
-  [k: string]: unknown
 }
 
-export function isMain(v: unknown): v is Main {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'com.atproto.repo.strongRef#main' ||
-      v.$type === 'com.atproto.repo.strongRef')
-  )
+export function isMain<V>(v: V) {
+  return is$typed(v, id, 'main')
+}
+
+export function validateMain(v: unknown) {
+  return lexicons.validate(`${id}#main`, v) as ValidationResult<Main>
 }
 
-export function validateMain(v: unknown): ValidationResult {
-  return lexicons.validate('com.atproto.repo.strongRef#main', v)
+export function isValidMain<V>(v: V): v is V & $Typed<Main> {
+  return isMain(v) && validateMain(v).success
 }

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

@@ -3,9 +3,11 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.repo.uploadBlob'
 
 export interface QueryParams {}
 
@@ -13,7 +15,6 @@ export type InputSchema = string | Uint8Array | Blob
 
 export interface OutputSchema {
   blob: BlobRef
-  [k: string]: unknown
 }
 
 export interface CallOptions {

package/src/client/types/com/atproto/server/activateAccount.ts

@@ -3,9 +3,11 @@
  */
 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 { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'com.atproto.server.activateAccount'
 
 export interface QueryParams {}