@atproto/lex-client 0.0.5 → 0.0.7

package/src/client.ts

@@ -1,4 +1,4 @@
-import { LexMap, LexValue } from '@atproto/lex-data'
+import { LexError, LexMap, LexValue } from '@atproto/lex-data'
 import {
   AtIdentifierString,
   CidString,
@@ -9,6 +9,7 @@ import {
   InferMethodParams,
   InferRecordKey,
   LexiconRecordKey,
+  Main,
   NsidString,
   Params,
   Procedure,
@@ -16,26 +17,34 @@ import {
   RecordSchema,
   Restricted,
   Schema,
+  getMain,
 } from '@atproto/lex-schema'
 import { Agent, AgentOptions, buildAgent } from './agent.js'
-import { com } from './lexicons.js'
-import {
-  BinaryBodyInit,
-  CallOptions,
-  Namespace,
-  Service,
-  getMain,
-} from './types.js'
+import { com } from './lexicons/index.js'
+import { LexRpcResponse, LexRpcResponseBody } from './response.js'
+import { BinaryBodyInit, CallOptions, Service } from './types.js'
 import { buildAtprotoHeaders } from './util.js'
-import { XrpcError } from './xrpc-error.js'
-import {
-  XrpcFailure,
-  XrpcOptions,
-  XrpcResponse,
-  XrpcResponseBody,
-  xrpc,
-  xrpcSafe,
-} from './xrpc.js'
+import { LexRpcFailure, LexRpcOptions, xrpc, xrpcSafe } from './xrpc.js'
+
+export type {
+  AtIdentifierString,
+  CidString,
+  DidString,
+  InferMethodInputBody,
+  InferMethodOutputBody,
+  InferMethodParams,
+  InferRecordKey,
+  LexMap,
+  LexValue,
+  LexiconRecordKey,
+  NsidString,
+  Params,
+  Procedure,
+  Query,
+  RecordSchema,
+  Restricted,
+  Schema,
+}
 
 export type ClientOptions = {
   labelers?: Iterable<DidString>
@@ -122,14 +131,14 @@ export type ListOutput<T extends RecordSchema> = InferMethodOutputBody<
   typeof com.atproto.repo.listRecords.main,
   Uint8Array
 > & {
-  records: ListRecord<T>[]
+  records: ListRecord<Infer<T>>[]
   // @NOTE Because the schema uses "type": "unknown" instead of an open union,
   // we have to use LexMap instead of TypedObject here.
   invalid: LexMap[]
 }
-export type ListRecord<T extends RecordSchema> =
+export type ListRecord<Value extends LexMap> =
   com.atproto.repo.listRecords.DefRecord & {
-    value: Infer<T>
+    value: Value
   }
 
 export class Client implements Agent {
@@ -148,10 +157,7 @@ export class Client implements Agent {
   public readonly labelers: Set<DidString>
 
   constructor(agent: Agent | AgentOptions, options: ClientOptions = {}) {
-    this.agent =
-      typeof agent === 'object' && 'fetchHandler' in agent
-        ? agent
-        : buildAgent(agent)
+    this.agent = buildAgent(agent)
     this.service = options.service
     this.labelers = new Set(options.labelers)
     this.headers = new Headers(options.headers)
@@ -167,7 +173,7 @@ export class Client implements Agent {
   }
 
   public assertAuthenticated(): asserts this is { did: DidString } {
-    if (!this.did) throw new XrpcError('AuthenticationRequired')
+    if (!this.did) throw new LexError('AuthenticationRequired')
   }
 
   public setLabelers(labelers: Iterable<DidString> = []) {
@@ -205,37 +211,37 @@ export class Client implements Agent {
   }
 
   /**
-   * @throws {XrpcFailure<M>} when the request fails or the response is an error
+   * @throws {LexRpcFailure<M>} when the request fails or the response is an error
    */
   async xrpc<const M extends Query | Procedure>(
-    ns: NonNullable<unknown> extends XrpcOptions<M>
-      ? Namespace<M>
+    ns: NonNullable<unknown> extends LexRpcOptions<M>
+      ? Main<M>
       : Restricted<'This XRPC method requires an "options" argument'>,
-  ): Promise<XrpcResponse<M>>
+  ): Promise<LexRpcResponse<M>>
   async xrpc<const M extends Query | Procedure>(
-    ns: Namespace<M>,
-    options: XrpcOptions<M>,
-  ): Promise<XrpcResponse<M>>
+    ns: Main<M>,
+    options: LexRpcOptions<M>,
+  ): Promise<LexRpcResponse<M>>
   async xrpc<const M extends Query | Procedure>(
-    ns: Namespace<M>,
-    options: XrpcOptions<M> = {} as XrpcOptions<M>,
-  ): Promise<XrpcResponse<M>> {
+    ns: Main<M>,
+    options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
+  ): Promise<LexRpcResponse<M>> {
     return xrpc(this, ns, options)
   }
 
   async xrpcSafe<const M extends Query | Procedure>(
-    ns: NonNullable<unknown> extends XrpcOptions<M>
-      ? Namespace<M>
+    ns: NonNullable<unknown> extends LexRpcOptions<M>
+      ? Main<M>
       : Restricted<'This XRPC method requires an "options" argument'>,
-  ): Promise<XrpcResponse<M> | XrpcFailure<M>>
+  ): Promise<LexRpcResponse<M> | LexRpcFailure<M>>
   async xrpcSafe<const M extends Query | Procedure>(
-    ns: Namespace<M>,
-    options: XrpcOptions<M>,
-  ): Promise<XrpcResponse<M> | XrpcFailure<M>>
+    ns: Main<M>,
+    options: LexRpcOptions<M>,
+  ): Promise<LexRpcResponse<M> | LexRpcFailure<M>>
   async xrpcSafe<const M extends Query | Procedure>(
-    ns: Namespace<M>,
-    options: XrpcOptions<M> = {} as XrpcOptions<M>,
-  ): Promise<XrpcResponse<M> | XrpcFailure<M>> {
+    ns: Main<M>,
+    options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
+  ): Promise<LexRpcResponse<M> | LexRpcFailure<M>> {
     return xrpcSafe(this, ns, options)
   }
 
@@ -343,16 +349,16 @@ export class Client implements Agent {
 
   public async call<const T extends Query>(
     ns: NonNullable<unknown> extends InferMethodParams<T>
-      ? Namespace<T>
+      ? Main<T>
       : Restricted<'This query type requires a "params" argument'>,
-  ): Promise<XrpcResponseBody<T>>
+  ): Promise<LexRpcResponseBody<T>>
   public async call<const T extends Action>(
     ns: void extends InferActionInput<T>
-      ? Namespace<T>
+      ? Main<T>
       : Restricted<'This action type requires an "input" argument'>,
   ): Promise<InferActionOutput<T>>
   public async call<const T extends Action | Procedure | Query>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     arg: T extends Action
       ? InferActionInput<T>
       : T extends Procedure
@@ -365,13 +371,13 @@ export class Client implements Agent {
     T extends Action
       ? InferActionOutput<T>
       : T extends Procedure
-        ? XrpcResponseBody<T>
+        ? LexRpcResponseBody<T>
         : T extends Query
-          ? XrpcResponseBody<T>
+          ? LexRpcResponseBody<T>
           : never
   >
   public async call(
-    ns: Namespace<Action> | Namespace<Procedure> | Namespace<Query>,
+    ns: Main<Action> | Main<Procedure> | Main<Query>,
     arg?: LexValue | Params,
     options: CallOptions = {},
   ): Promise<unknown> {
@@ -394,17 +400,17 @@ export class Client implements Agent {
 
   public async create<const T extends RecordSchema>(
     ns: NonNullable<unknown> extends CreateOptions<T>
-      ? Namespace<T>
+      ? Main<T>
       : Restricted<'This record type requires an "options" argument'>,
     input: Omit<Infer<T>, '$type'>,
   ): Promise<CreateOutput>
   public async create<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     input: Omit<Infer<T>, '$type'>,
     options: CreateOptions<T>,
   ): Promise<CreateOutput>
   public async create<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     input: Omit<Infer<T>, '$type'>,
     options: CreateOptions<T> = {} as CreateOptions<T>,
   ): Promise<CreateOutput> {
@@ -419,15 +425,15 @@ export class Client implements Agent {
 
   public async delete<const T extends RecordSchema>(
     ns: NonNullable<unknown> extends DeleteOptions<T>
-      ? Namespace<T>
+      ? Main<T>
       : Restricted<'This record type requires an "options" argument'>,
   ): Promise<DeleteOutput>
   public async delete<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     options?: DeleteOptions<T>,
   ): Promise<DeleteOutput>
   public async delete<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     options: DeleteOptions<T> = {} as DeleteOptions<T>,
   ): Promise<DeleteOutput> {
     const schema = getMain(ns)
@@ -440,15 +446,15 @@ export class Client implements Agent {
 
   public async get<const T extends RecordSchema>(
     ns: T['key'] extends `literal:${string}`
-      ? Namespace<T>
+      ? Main<T>
       : Restricted<'This record type requires an "options" argument'>,
   ): Promise<GetOutput<T>>
   public async get<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     options?: GetOptions<T>,
   ): Promise<GetOutput<T>>
   public async get<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     options: GetOptions<T> = {} as GetOptions<T>,
   ): Promise<GetOutput<T>> {
     const schema = getMain(ns)
@@ -462,17 +468,17 @@ export class Client implements Agent {
 
   public async put<const T extends RecordSchema>(
     ns: NonNullable<unknown> extends PutOptions<T>
-      ? Namespace<T>
+      ? Main<T>
       : Restricted<'This record type requires an "options" argument'>,
     input: Omit<Infer<T>, '$type'>,
   ): Promise<PutOutput>
   public async put<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     input: Omit<Infer<T>, '$type'>,
     options: PutOptions<T>,
   ): Promise<PutOutput>
   public async put<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     input: Omit<Infer<T>, '$type'>,
     options: PutOptions<T> = {} as PutOptions<T>,
   ): Promise<PutOutput> {
@@ -485,13 +491,13 @@ export class Client implements Agent {
   }
 
   async list<const T extends RecordSchema>(
-    ns: Namespace<T>,
+    ns: Main<T>,
     options?: ListOptions,
   ): Promise<ListOutput<T>> {
     const schema = getMain(ns)
     const { body } = await this.listRecords(schema.$type, options)
 
-    const records: ListRecord<T>[] = []
+    const records: ListRecord<Infer<T>>[] = []
     const invalid: LexMap[] = []
 
     for (const record of body.records) {

package/src/{xrpc-error.ts → errors.ts}

@@ -1,37 +1,26 @@
+import { LexError, LexErrorCode, LexErrorData } from '@atproto/lex-data'
 import { l } from '@atproto/lex-schema'
 import { Payload } from './util.js'
 
-export type XrpcErrorCode = string
-export const xrpcErrorCodeSchema: l.Schema<XrpcErrorCode> = l.string({
-  minLength: 1,
-})
+export type LexRpcErrorPayload<N extends LexErrorCode = LexErrorCode> = Payload<
+  LexErrorData<N>,
+  'application/json'
+>
 
-export class XrpcError<N extends XrpcErrorCode = XrpcErrorCode> extends Error {
-  name = 'XrpcError'
+export class LexRpcError<
+  N extends LexErrorCode = LexErrorCode,
+> extends LexError<N> {
+  name = 'LexRpcError'
 
   constructor(
-    readonly error: N,
-    message: string = `An ${error} XRPC error occurred.`,
+    error: N,
+    message: string = `${error} Lexicon RPC error`,
     options?: ErrorOptions,
   ) {
-    super(message, options)
+    super(error, message, options)
   }
 }
 
-export type XrpcErrorBody<N extends XrpcErrorCode = XrpcErrorCode> = {
-  error: N
-  message?: string
-}
-export type XrpcErrorPayload<N extends XrpcErrorCode = XrpcErrorCode> = {
-  encoding: 'application/json'
-  body: XrpcErrorBody<N>
-}
-
-const xrpcErrorBodySchema: l.Schema<XrpcErrorBody> = l.object({
-  error: xrpcErrorCodeSchema,
-  message: l.optional(l.string()),
-})
-
 /**
  * All unsuccessful responses should follow a standard error response
  * schema. The Content-Type should be application/json, and the payload
@@ -44,20 +33,20 @@ const xrpcErrorBodySchema: l.Schema<XrpcErrorBody> = l.object({
  *
  * This function checks whether a given payload matches this schema.
  */
-export function isXrpcErrorPayload(
+export function isLexRpcErrorPayload(
   payload: Payload | null,
-): payload is XrpcErrorPayload {
+): payload is LexRpcErrorPayload {
   return (
     payload !== null &&
     payload.encoding === 'application/json' &&
-    xrpcErrorBodySchema.matches(payload.body)
+    l.lexErrorData.matches(payload.body)
   )
 }
 
 /**
  * Interface representing a failed XRPC request result.
  */
-type XrpcFailureResult<N extends XrpcErrorCode, E> = l.ResultFailure<E> & {
+type LexRpcFailureResult<N extends LexErrorCode, E> = l.ResultFailure<E> & {
   readonly error: N
   shouldRetry(): boolean
   matchesSchema(): boolean
@@ -67,20 +56,20 @@ type XrpcFailureResult<N extends XrpcErrorCode, E> = l.ResultFailure<E> & {
  * Class used to represent an HTTP request that resulted in an XRPC method error
  * That is, a non-2xx response with a valid XRPC error payload.
  */
-export class XrpcResponseError<
+export class LexRpcResponseError<
     M extends l.Procedure | l.Query = l.Procedure | l.Query,
-    N extends XrpcErrorCode = XrpcErrorCode,
+    N extends LexErrorCode = LexErrorCode,
   >
-  extends XrpcError<N>
-  implements XrpcFailureResult<N, XrpcResponseError<M, N>>
+  extends LexRpcError<N>
+  implements LexRpcFailureResult<N, LexRpcResponseError<M, N>>
 {
-  name = 'XrpcResponseError' as const
+  name = 'LexRpcResponseError'
 
   constructor(
     readonly method: M,
     readonly status: number,
     readonly headers: Headers,
-    readonly payload: XrpcErrorPayload<N>,
+    readonly payload: LexRpcErrorPayload<N>,
     options?: ErrorOptions,
   ) {
     const { error, message } = payload.body
@@ -93,14 +82,14 @@ export class XrpcResponseError<
     return this as this
   }
 
-  get body(): XrpcErrorBody {
+  get body(): LexErrorData {
     return this.payload.body
   }
 
   matchesSchema(): this is M extends {
     errors: readonly (infer E extends string)[]
   }
-    ? XrpcResponseError<M, E>
+    ? LexRpcResponseError<M, E>
     : never {
     return this.method.errors?.includes(this.error) ?? false
   }
@@ -111,16 +100,29 @@ export class XrpcResponseError<
 
     return true
   }
+
+  toJSON() {
+    return this.payload.body
+  }
+
+  toResponse(): Response {
+    const { status, headers } = this
+    return Response.json(this.toJSON(), { status, headers })
+  }
 }
 
 /**
  * This class represents an invalid XRPC response from the server.
  */
-export class XrpcInvalidResponseError
-  extends XrpcError<'UpstreamFailure'>
-  implements XrpcFailureResult<'UpstreamFailure', XrpcInvalidResponseError>
+export class LexRpcUpstreamError<
+    N extends 'InvalidResponse' | 'UpstreamFailure' =
+      | 'InvalidResponse'
+      | 'UpstreamFailure',
+  >
+  extends LexRpcError<N>
+  implements LexRpcFailureResult<N, LexRpcUpstreamError<N>>
 {
-  name = 'XrpcInvalidResponseError' as const
+  name = 'LexRpcUpstreamError' as const
 
   // For debugging purposes, we keep the response details here
   readonly response: {
@@ -130,12 +132,13 @@ export class XrpcInvalidResponseError
   }
 
   constructor(
+    error: N,
     message: string,
     response: { status: number; headers: Headers },
     payload: Payload | null,
     options?: ErrorOptions,
   ) {
-    super('UpstreamFailure', message, { cause: options?.cause })
+    super(error, message, { cause: options?.cause })
     this.response = {
       status: response.status,
       headers: response.headers,
@@ -157,13 +160,17 @@ export class XrpcInvalidResponseError
     // Do not retry client errors
     return this.response.status >= 500
   }
+
+  toResponse(): Response {
+    return Response.json(this.toJSON(), { status: 502 })
+  }
 }
 
-export class XrpcUnexpectedError
-  extends XrpcError<'InternalServerError'>
-  implements XrpcFailureResult<'InternalServerError', unknown>
+export class LexRpcUnexpectedError
+  extends LexRpcError<'InternalServerError'>
+  implements LexRpcFailureResult<'InternalServerError', unknown>
 {
-  name = 'XrpcUnexpectedError' as const
+  name = 'LexRpcUnexpectedError' as const
 
   protected constructor(message: string, options: Required<ErrorOptions>) {
     super('InternalServerError', message, options)
@@ -183,13 +190,17 @@ export class XrpcUnexpectedError
     return true
   }
 
+  toResponse(): Response {
+    return Response.json(this.toJSON(), { status: 500 })
+  }
+
   static from(
     cause: unknown,
-    message: string = cause instanceof XrpcError
+    message: string = cause instanceof LexError
       ? cause.message
       : 'XRPC request failed',
-  ): XrpcUnexpectedError {
-    if (cause instanceof XrpcUnexpectedError) return cause
-    return new XrpcUnexpectedError(message, { cause })
+  ): LexRpcUnexpectedError {
+    if (cause instanceof LexRpcUnexpectedError) return cause
+    return new LexRpcUnexpectedError(message, { cause })
   }
 }

package/src/index.ts

@@ -1,4 +1,6 @@
 export * from './agent.js'
 export * from './client.js'
+export * from './errors.js'
+export * from './response.js'
 export * from './types.js'
 export * from './xrpc.js'

package/src/lexicons/com/atproto/repo/createRecord.defs.ts

@@ -14,35 +14,29 @@ const main =
   /*#__PURE__*/
   l.procedure(
     $nsid,
-    /*#__PURE__*/ l.params({}),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
-        collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
-        rkey: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.string({ format: 'record-key', maxLength: 512 }),
+    /*#__PURE__*/ l.params(),
+    /*#__PURE__*/ l.jsonPayload({
+      repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
+      collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
+      rkey: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.string({ format: 'record-key', maxLength: 512 }),
+      ),
+      validate: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
+      record: /*#__PURE__*/ l.unknownObject(),
+      swapCommit: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.string({ format: 'cid' }),
+      ),
+    }),
+    /*#__PURE__*/ l.jsonPayload({
+      uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
+      cid: /*#__PURE__*/ l.string({ format: 'cid' }),
+      commit: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
+          (() => RepoDefs.commitMeta) as any,
         ),
-        validate: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
-        record: /*#__PURE__*/ l.unknownObject(),
-        swapCommit: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.string({ format: 'cid' }),
-        ),
-      }),
-    ),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
-        cid: /*#__PURE__*/ l.string({ format: 'cid' }),
-        commit: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
-            (() => RepoDefs.commitMeta) as any,
-          ),
-        ),
-        validationStatus: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
-      }),
-    ),
+      ),
+      validationStatus: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
+    }),
     ['InvalidSwap'],
   )
 export { main }

package/src/lexicons/com/atproto/repo/deleteRecord.defs.ts

@@ -14,31 +14,25 @@ const main =
   /*#__PURE__*/
   l.procedure(
     $nsid,
-    /*#__PURE__*/ l.params({}),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
-        collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
-        rkey: /*#__PURE__*/ l.string({ format: 'record-key' }),
-        swapRecord: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.string({ format: 'cid' }),
+    /*#__PURE__*/ l.params(),
+    /*#__PURE__*/ l.jsonPayload({
+      repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
+      collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
+      rkey: /*#__PURE__*/ l.string({ format: 'record-key' }),
+      swapRecord: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.string({ format: 'cid' }),
+      ),
+      swapCommit: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.string({ format: 'cid' }),
+      ),
+    }),
+    /*#__PURE__*/ l.jsonPayload({
+      commit: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
+          (() => RepoDefs.commitMeta) as any,
         ),
-        swapCommit: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.string({ format: 'cid' }),
-        ),
-      }),
-    ),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        commit: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
-            (() => RepoDefs.commitMeta) as any,
-          ),
-        ),
-      }),
-    ),
+      ),
+    }),
     ['InvalidSwap'],
   )
 export { main }

package/src/lexicons/com/atproto/repo/getRecord.defs.ts

@@ -19,16 +19,11 @@ const main =
       rkey: /*#__PURE__*/ l.string({ format: 'record-key' }),
       cid: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string({ format: 'cid' })),
     }),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
-        cid: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.string({ format: 'cid' }),
-        ),
-        value: /*#__PURE__*/ l.unknownObject(),
-      }),
-    ),
+    /*#__PURE__*/ l.jsonPayload({
+      uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
+      cid: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string({ format: 'cid' })),
+      value: /*#__PURE__*/ l.unknownObject(),
+    }),
     ['RecordNotFound'],
   )
 export { main }

package/src/lexicons/com/atproto/repo/listRecords.defs.ts

@@ -22,15 +22,12 @@ const main =
       cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
       reverse: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
     }),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
-        records: /*#__PURE__*/ l.array(
-          /*#__PURE__*/ l.ref<Def$0>((() => def$0) as any),
-        ),
-      }),
-    ),
+    /*#__PURE__*/ l.jsonPayload({
+      cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
+      records: /*#__PURE__*/ l.array(
+        /*#__PURE__*/ l.ref<Def$0>((() => def$0) as any),
+      ),
+    }),
   )
 export { main }