@atproto/pds 0.4.158 → 0.4.159

package/src/lexicon/index.ts

@@ -2,11 +2,12 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import {
-  createServer as createXrpcServer,
-  Server as XrpcServer,
+  type Auth,
   type Options as XrpcOptions,
-  type AuthVerifier,
-  type StreamAuthVerifier,
+  Server as XrpcServer,
+  type StreamConfigOrHandler,
+  type MethodConfigOrHandler,
+  createServer as createXrpcServer,
 } from '@atproto/xrpc-server'
 import { schemas } from './lexicons.js'
 import * as ComAtprotoAdminDeleteAccount from './types/com/atproto/admin/deleteAccount.js'
@@ -108,8 +109,8 @@ import * as AppBskyFeedGetFeedGenerators from './types/app/bsky/feed/getFeedGene
 import * as AppBskyFeedGetFeedSkeleton from './types/app/bsky/feed/getFeedSkeleton.js'
 import * as AppBskyFeedGetLikes from './types/app/bsky/feed/getLikes.js'
 import * as AppBskyFeedGetListFeed from './types/app/bsky/feed/getListFeed.js'
-import * as AppBskyFeedGetPostThread from './types/app/bsky/feed/getPostThread.js'
 import * as AppBskyFeedGetPosts from './types/app/bsky/feed/getPosts.js'
+import * as AppBskyFeedGetPostThread from './types/app/bsky/feed/getPostThread.js'
 import * as AppBskyFeedGetQuotes from './types/app/bsky/feed/getQuotes.js'
 import * as AppBskyFeedGetRepostedBy from './types/app/bsky/feed/getRepostedBy.js'
 import * as AppBskyFeedGetSuggestedFeeds from './types/app/bsky/feed/getSuggestedFeeds.js'
@@ -341,165 +342,180 @@ export class ComAtprotoAdminNS {
     this._server = server
   }
 
-  deleteAccount<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminDeleteAccount.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminDeleteAccount.HandlerReqCtx<ExtractAuth<AV>>
+  deleteAccount<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminDeleteAccount.QueryParams,
+      ComAtprotoAdminDeleteAccount.HandlerInput,
+      ComAtprotoAdminDeleteAccount.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.deleteAccount' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  disableAccountInvites<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminDisableAccountInvites.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminDisableAccountInvites.HandlerReqCtx<ExtractAuth<AV>>
+  disableAccountInvites<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminDisableAccountInvites.QueryParams,
+      ComAtprotoAdminDisableAccountInvites.HandlerInput,
+      ComAtprotoAdminDisableAccountInvites.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.disableAccountInvites' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  disableInviteCodes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminDisableInviteCodes.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminDisableInviteCodes.HandlerReqCtx<ExtractAuth<AV>>
+  disableInviteCodes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminDisableInviteCodes.QueryParams,
+      ComAtprotoAdminDisableInviteCodes.HandlerInput,
+      ComAtprotoAdminDisableInviteCodes.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.disableInviteCodes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  enableAccountInvites<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminEnableAccountInvites.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminEnableAccountInvites.HandlerReqCtx<ExtractAuth<AV>>
+  enableAccountInvites<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminEnableAccountInvites.QueryParams,
+      ComAtprotoAdminEnableAccountInvites.HandlerInput,
+      ComAtprotoAdminEnableAccountInvites.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.enableAccountInvites' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getAccountInfo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminGetAccountInfo.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminGetAccountInfo.HandlerReqCtx<ExtractAuth<AV>>
+  getAccountInfo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminGetAccountInfo.QueryParams,
+      ComAtprotoAdminGetAccountInfo.HandlerInput,
+      ComAtprotoAdminGetAccountInfo.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.getAccountInfo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getAccountInfos<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminGetAccountInfos.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminGetAccountInfos.HandlerReqCtx<ExtractAuth<AV>>
+  getAccountInfos<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminGetAccountInfos.QueryParams,
+      ComAtprotoAdminGetAccountInfos.HandlerInput,
+      ComAtprotoAdminGetAccountInfos.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.getAccountInfos' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getInviteCodes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminGetInviteCodes.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminGetInviteCodes.HandlerReqCtx<ExtractAuth<AV>>
+  getInviteCodes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminGetInviteCodes.QueryParams,
+      ComAtprotoAdminGetInviteCodes.HandlerInput,
+      ComAtprotoAdminGetInviteCodes.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.getInviteCodes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSubjectStatus<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminGetSubjectStatus.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminGetSubjectStatus.HandlerReqCtx<ExtractAuth<AV>>
+  getSubjectStatus<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminGetSubjectStatus.QueryParams,
+      ComAtprotoAdminGetSubjectStatus.HandlerInput,
+      ComAtprotoAdminGetSubjectStatus.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.getSubjectStatus' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchAccounts<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminSearchAccounts.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminSearchAccounts.HandlerReqCtx<ExtractAuth<AV>>
+  searchAccounts<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminSearchAccounts.QueryParams,
+      ComAtprotoAdminSearchAccounts.HandlerInput,
+      ComAtprotoAdminSearchAccounts.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.searchAccounts' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  sendEmail<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminSendEmail.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminSendEmail.HandlerReqCtx<ExtractAuth<AV>>
+  sendEmail<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminSendEmail.QueryParams,
+      ComAtprotoAdminSendEmail.HandlerInput,
+      ComAtprotoAdminSendEmail.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.sendEmail' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateAccountEmail<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminUpdateAccountEmail.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminUpdateAccountEmail.HandlerReqCtx<ExtractAuth<AV>>
+  updateAccountEmail<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminUpdateAccountEmail.QueryParams,
+      ComAtprotoAdminUpdateAccountEmail.HandlerInput,
+      ComAtprotoAdminUpdateAccountEmail.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.updateAccountEmail' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateAccountHandle<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminUpdateAccountHandle.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminUpdateAccountHandle.HandlerReqCtx<ExtractAuth<AV>>
+  updateAccountHandle<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminUpdateAccountHandle.QueryParams,
+      ComAtprotoAdminUpdateAccountHandle.HandlerInput,
+      ComAtprotoAdminUpdateAccountHandle.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.updateAccountHandle' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateAccountPassword<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminUpdateAccountPassword.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminUpdateAccountPassword.HandlerReqCtx<ExtractAuth<AV>>
+  updateAccountPassword<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminUpdateAccountPassword.QueryParams,
+      ComAtprotoAdminUpdateAccountPassword.HandlerInput,
+      ComAtprotoAdminUpdateAccountPassword.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.updateAccountPassword' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateAccountSigningKey<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminUpdateAccountSigningKey.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminUpdateAccountSigningKey.HandlerReqCtx<ExtractAuth<AV>>
+  updateAccountSigningKey<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminUpdateAccountSigningKey.QueryParams,
+      ComAtprotoAdminUpdateAccountSigningKey.HandlerInput,
+      ComAtprotoAdminUpdateAccountSigningKey.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.updateAccountSigningKey' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateSubjectStatus<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoAdminUpdateSubjectStatus.Handler<ExtractAuth<AV>>,
-      ComAtprotoAdminUpdateSubjectStatus.HandlerReqCtx<ExtractAuth<AV>>
+  updateSubjectStatus<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoAdminUpdateSubjectStatus.QueryParams,
+      ComAtprotoAdminUpdateSubjectStatus.HandlerInput,
+      ComAtprotoAdminUpdateSubjectStatus.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.admin.updateSubjectStatus' // @ts-ignore
@@ -514,103 +530,108 @@ export class ComAtprotoIdentityNS {
     this._server = server
   }
 
-  getRecommendedDidCredentials<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentityGetRecommendedDidCredentials.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentityGetRecommendedDidCredentials.HandlerReqCtx<
-        ExtractAuth<AV>
-      >
+  getRecommendedDidCredentials<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentityGetRecommendedDidCredentials.QueryParams,
+      ComAtprotoIdentityGetRecommendedDidCredentials.HandlerInput,
+      ComAtprotoIdentityGetRecommendedDidCredentials.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.getRecommendedDidCredentials' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  refreshIdentity<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentityRefreshIdentity.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentityRefreshIdentity.HandlerReqCtx<ExtractAuth<AV>>
+  refreshIdentity<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentityRefreshIdentity.QueryParams,
+      ComAtprotoIdentityRefreshIdentity.HandlerInput,
+      ComAtprotoIdentityRefreshIdentity.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.refreshIdentity' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  requestPlcOperationSignature<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentityRequestPlcOperationSignature.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentityRequestPlcOperationSignature.HandlerReqCtx<
-        ExtractAuth<AV>
-      >
+  requestPlcOperationSignature<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentityRequestPlcOperationSignature.QueryParams,
+      ComAtprotoIdentityRequestPlcOperationSignature.HandlerInput,
+      ComAtprotoIdentityRequestPlcOperationSignature.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.requestPlcOperationSignature' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  resolveDid<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentityResolveDid.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentityResolveDid.HandlerReqCtx<ExtractAuth<AV>>
+  resolveDid<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentityResolveDid.QueryParams,
+      ComAtprotoIdentityResolveDid.HandlerInput,
+      ComAtprotoIdentityResolveDid.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.resolveDid' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  resolveHandle<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentityResolveHandle.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentityResolveHandle.HandlerReqCtx<ExtractAuth<AV>>
+  resolveHandle<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentityResolveHandle.QueryParams,
+      ComAtprotoIdentityResolveHandle.HandlerInput,
+      ComAtprotoIdentityResolveHandle.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.resolveHandle' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  resolveIdentity<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentityResolveIdentity.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentityResolveIdentity.HandlerReqCtx<ExtractAuth<AV>>
+  resolveIdentity<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentityResolveIdentity.QueryParams,
+      ComAtprotoIdentityResolveIdentity.HandlerInput,
+      ComAtprotoIdentityResolveIdentity.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.resolveIdentity' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  signPlcOperation<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentitySignPlcOperation.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentitySignPlcOperation.HandlerReqCtx<ExtractAuth<AV>>
+  signPlcOperation<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentitySignPlcOperation.QueryParams,
+      ComAtprotoIdentitySignPlcOperation.HandlerInput,
+      ComAtprotoIdentitySignPlcOperation.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.signPlcOperation' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  submitPlcOperation<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentitySubmitPlcOperation.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentitySubmitPlcOperation.HandlerReqCtx<ExtractAuth<AV>>
+  submitPlcOperation<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentitySubmitPlcOperation.QueryParams,
+      ComAtprotoIdentitySubmitPlcOperation.HandlerInput,
+      ComAtprotoIdentitySubmitPlcOperation.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.submitPlcOperation' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateHandle<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoIdentityUpdateHandle.Handler<ExtractAuth<AV>>,
-      ComAtprotoIdentityUpdateHandle.HandlerReqCtx<ExtractAuth<AV>>
+  updateHandle<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoIdentityUpdateHandle.QueryParams,
+      ComAtprotoIdentityUpdateHandle.HandlerInput,
+      ComAtprotoIdentityUpdateHandle.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.identity.updateHandle' // @ts-ignore
@@ -625,22 +646,23 @@ export class ComAtprotoLabelNS {
     this._server = server
   }
 
-  queryLabels<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoLabelQueryLabels.Handler<ExtractAuth<AV>>,
-      ComAtprotoLabelQueryLabels.HandlerReqCtx<ExtractAuth<AV>>
+  queryLabels<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoLabelQueryLabels.QueryParams,
+      ComAtprotoLabelQueryLabels.HandlerInput,
+      ComAtprotoLabelQueryLabels.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.label.queryLabels' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  subscribeLabels<AV extends StreamAuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoLabelSubscribeLabels.Handler<ExtractAuth<AV>>,
-      ComAtprotoLabelSubscribeLabels.HandlerReqCtx<ExtractAuth<AV>>
+  subscribeLabels<A extends Auth = void>(
+    cfg: StreamConfigOrHandler<
+      A,
+      ComAtprotoLabelSubscribeLabels.QueryParams,
+      ComAtprotoLabelSubscribeLabels.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.label.subscribeLabels' // @ts-ignore
@@ -663,11 +685,12 @@ export class ComAtprotoModerationNS {
     this._server = server
   }
 
-  createReport<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoModerationCreateReport.Handler<ExtractAuth<AV>>,
-      ComAtprotoModerationCreateReport.HandlerReqCtx<ExtractAuth<AV>>
+  createReport<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoModerationCreateReport.QueryParams,
+      ComAtprotoModerationCreateReport.HandlerInput,
+      ComAtprotoModerationCreateReport.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.moderation.createReport' // @ts-ignore
@@ -682,110 +705,120 @@ export class ComAtprotoRepoNS {
     this._server = server
   }
 
-  applyWrites<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoApplyWrites.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoApplyWrites.HandlerReqCtx<ExtractAuth<AV>>
+  applyWrites<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoApplyWrites.QueryParams,
+      ComAtprotoRepoApplyWrites.HandlerInput,
+      ComAtprotoRepoApplyWrites.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.applyWrites' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  createRecord<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoCreateRecord.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoCreateRecord.HandlerReqCtx<ExtractAuth<AV>>
+  createRecord<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoCreateRecord.QueryParams,
+      ComAtprotoRepoCreateRecord.HandlerInput,
+      ComAtprotoRepoCreateRecord.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.createRecord' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteRecord<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoDeleteRecord.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoDeleteRecord.HandlerReqCtx<ExtractAuth<AV>>
+  deleteRecord<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoDeleteRecord.QueryParams,
+      ComAtprotoRepoDeleteRecord.HandlerInput,
+      ComAtprotoRepoDeleteRecord.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.deleteRecord' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  describeRepo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoDescribeRepo.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoDescribeRepo.HandlerReqCtx<ExtractAuth<AV>>
+  describeRepo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoDescribeRepo.QueryParams,
+      ComAtprotoRepoDescribeRepo.HandlerInput,
+      ComAtprotoRepoDescribeRepo.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.describeRepo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRecord<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoGetRecord.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoGetRecord.HandlerReqCtx<ExtractAuth<AV>>
+  getRecord<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoGetRecord.QueryParams,
+      ComAtprotoRepoGetRecord.HandlerInput,
+      ComAtprotoRepoGetRecord.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.getRecord' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  importRepo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoImportRepo.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoImportRepo.HandlerReqCtx<ExtractAuth<AV>>
+  importRepo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoImportRepo.QueryParams,
+      ComAtprotoRepoImportRepo.HandlerInput,
+      ComAtprotoRepoImportRepo.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.importRepo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listMissingBlobs<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoListMissingBlobs.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoListMissingBlobs.HandlerReqCtx<ExtractAuth<AV>>
+  listMissingBlobs<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoListMissingBlobs.QueryParams,
+      ComAtprotoRepoListMissingBlobs.HandlerInput,
+      ComAtprotoRepoListMissingBlobs.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.listMissingBlobs' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listRecords<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoListRecords.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoListRecords.HandlerReqCtx<ExtractAuth<AV>>
+  listRecords<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoListRecords.QueryParams,
+      ComAtprotoRepoListRecords.HandlerInput,
+      ComAtprotoRepoListRecords.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.listRecords' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  putRecord<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoPutRecord.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoPutRecord.HandlerReqCtx<ExtractAuth<AV>>
+  putRecord<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoPutRecord.QueryParams,
+      ComAtprotoRepoPutRecord.HandlerInput,
+      ComAtprotoRepoPutRecord.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.putRecord' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  uploadBlob<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoRepoUploadBlob.Handler<ExtractAuth<AV>>,
-      ComAtprotoRepoUploadBlob.HandlerReqCtx<ExtractAuth<AV>>
+  uploadBlob<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoRepoUploadBlob.QueryParams,
+      ComAtprotoRepoUploadBlob.HandlerInput,
+      ComAtprotoRepoUploadBlob.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.repo.uploadBlob' // @ts-ignore
@@ -800,275 +833,300 @@ export class ComAtprotoServerNS {
     this._server = server
   }
 
-  activateAccount<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerActivateAccount.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerActivateAccount.HandlerReqCtx<ExtractAuth<AV>>
+  activateAccount<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerActivateAccount.QueryParams,
+      ComAtprotoServerActivateAccount.HandlerInput,
+      ComAtprotoServerActivateAccount.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.activateAccount' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  checkAccountStatus<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerCheckAccountStatus.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerCheckAccountStatus.HandlerReqCtx<ExtractAuth<AV>>
+  checkAccountStatus<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerCheckAccountStatus.QueryParams,
+      ComAtprotoServerCheckAccountStatus.HandlerInput,
+      ComAtprotoServerCheckAccountStatus.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.checkAccountStatus' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  confirmEmail<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerConfirmEmail.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerConfirmEmail.HandlerReqCtx<ExtractAuth<AV>>
+  confirmEmail<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerConfirmEmail.QueryParams,
+      ComAtprotoServerConfirmEmail.HandlerInput,
+      ComAtprotoServerConfirmEmail.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.confirmEmail' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  createAccount<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerCreateAccount.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerCreateAccount.HandlerReqCtx<ExtractAuth<AV>>
+  createAccount<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerCreateAccount.QueryParams,
+      ComAtprotoServerCreateAccount.HandlerInput,
+      ComAtprotoServerCreateAccount.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.createAccount' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  createAppPassword<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerCreateAppPassword.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerCreateAppPassword.HandlerReqCtx<ExtractAuth<AV>>
+  createAppPassword<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerCreateAppPassword.QueryParams,
+      ComAtprotoServerCreateAppPassword.HandlerInput,
+      ComAtprotoServerCreateAppPassword.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.createAppPassword' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  createInviteCode<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerCreateInviteCode.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerCreateInviteCode.HandlerReqCtx<ExtractAuth<AV>>
+  createInviteCode<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerCreateInviteCode.QueryParams,
+      ComAtprotoServerCreateInviteCode.HandlerInput,
+      ComAtprotoServerCreateInviteCode.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.createInviteCode' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  createInviteCodes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerCreateInviteCodes.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerCreateInviteCodes.HandlerReqCtx<ExtractAuth<AV>>
+  createInviteCodes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerCreateInviteCodes.QueryParams,
+      ComAtprotoServerCreateInviteCodes.HandlerInput,
+      ComAtprotoServerCreateInviteCodes.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.createInviteCodes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  createSession<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerCreateSession.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerCreateSession.HandlerReqCtx<ExtractAuth<AV>>
+  createSession<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerCreateSession.QueryParams,
+      ComAtprotoServerCreateSession.HandlerInput,
+      ComAtprotoServerCreateSession.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.createSession' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deactivateAccount<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerDeactivateAccount.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerDeactivateAccount.HandlerReqCtx<ExtractAuth<AV>>
+  deactivateAccount<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerDeactivateAccount.QueryParams,
+      ComAtprotoServerDeactivateAccount.HandlerInput,
+      ComAtprotoServerDeactivateAccount.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.deactivateAccount' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteAccount<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerDeleteAccount.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerDeleteAccount.HandlerReqCtx<ExtractAuth<AV>>
+  deleteAccount<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerDeleteAccount.QueryParams,
+      ComAtprotoServerDeleteAccount.HandlerInput,
+      ComAtprotoServerDeleteAccount.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.deleteAccount' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteSession<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerDeleteSession.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerDeleteSession.HandlerReqCtx<ExtractAuth<AV>>
+  deleteSession<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerDeleteSession.QueryParams,
+      ComAtprotoServerDeleteSession.HandlerInput,
+      ComAtprotoServerDeleteSession.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.deleteSession' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  describeServer<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerDescribeServer.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerDescribeServer.HandlerReqCtx<ExtractAuth<AV>>
+  describeServer<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerDescribeServer.QueryParams,
+      ComAtprotoServerDescribeServer.HandlerInput,
+      ComAtprotoServerDescribeServer.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.describeServer' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getAccountInviteCodes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerGetAccountInviteCodes.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerGetAccountInviteCodes.HandlerReqCtx<ExtractAuth<AV>>
+  getAccountInviteCodes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerGetAccountInviteCodes.QueryParams,
+      ComAtprotoServerGetAccountInviteCodes.HandlerInput,
+      ComAtprotoServerGetAccountInviteCodes.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.getAccountInviteCodes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getServiceAuth<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerGetServiceAuth.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerGetServiceAuth.HandlerReqCtx<ExtractAuth<AV>>
+  getServiceAuth<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerGetServiceAuth.QueryParams,
+      ComAtprotoServerGetServiceAuth.HandlerInput,
+      ComAtprotoServerGetServiceAuth.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.getServiceAuth' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSession<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerGetSession.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerGetSession.HandlerReqCtx<ExtractAuth<AV>>
+  getSession<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerGetSession.QueryParams,
+      ComAtprotoServerGetSession.HandlerInput,
+      ComAtprotoServerGetSession.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.getSession' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listAppPasswords<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerListAppPasswords.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerListAppPasswords.HandlerReqCtx<ExtractAuth<AV>>
+  listAppPasswords<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerListAppPasswords.QueryParams,
+      ComAtprotoServerListAppPasswords.HandlerInput,
+      ComAtprotoServerListAppPasswords.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.listAppPasswords' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  refreshSession<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerRefreshSession.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerRefreshSession.HandlerReqCtx<ExtractAuth<AV>>
+  refreshSession<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerRefreshSession.QueryParams,
+      ComAtprotoServerRefreshSession.HandlerInput,
+      ComAtprotoServerRefreshSession.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.refreshSession' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  requestAccountDelete<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerRequestAccountDelete.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerRequestAccountDelete.HandlerReqCtx<ExtractAuth<AV>>
+  requestAccountDelete<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerRequestAccountDelete.QueryParams,
+      ComAtprotoServerRequestAccountDelete.HandlerInput,
+      ComAtprotoServerRequestAccountDelete.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.requestAccountDelete' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  requestEmailConfirmation<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerRequestEmailConfirmation.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerRequestEmailConfirmation.HandlerReqCtx<ExtractAuth<AV>>
+  requestEmailConfirmation<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerRequestEmailConfirmation.QueryParams,
+      ComAtprotoServerRequestEmailConfirmation.HandlerInput,
+      ComAtprotoServerRequestEmailConfirmation.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.requestEmailConfirmation' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  requestEmailUpdate<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerRequestEmailUpdate.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerRequestEmailUpdate.HandlerReqCtx<ExtractAuth<AV>>
+  requestEmailUpdate<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerRequestEmailUpdate.QueryParams,
+      ComAtprotoServerRequestEmailUpdate.HandlerInput,
+      ComAtprotoServerRequestEmailUpdate.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.requestEmailUpdate' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  requestPasswordReset<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerRequestPasswordReset.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerRequestPasswordReset.HandlerReqCtx<ExtractAuth<AV>>
+  requestPasswordReset<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerRequestPasswordReset.QueryParams,
+      ComAtprotoServerRequestPasswordReset.HandlerInput,
+      ComAtprotoServerRequestPasswordReset.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.requestPasswordReset' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  reserveSigningKey<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerReserveSigningKey.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerReserveSigningKey.HandlerReqCtx<ExtractAuth<AV>>
+  reserveSigningKey<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerReserveSigningKey.QueryParams,
+      ComAtprotoServerReserveSigningKey.HandlerInput,
+      ComAtprotoServerReserveSigningKey.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.reserveSigningKey' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  resetPassword<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerResetPassword.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerResetPassword.HandlerReqCtx<ExtractAuth<AV>>
+  resetPassword<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerResetPassword.QueryParams,
+      ComAtprotoServerResetPassword.HandlerInput,
+      ComAtprotoServerResetPassword.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.resetPassword' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  revokeAppPassword<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerRevokeAppPassword.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerRevokeAppPassword.HandlerReqCtx<ExtractAuth<AV>>
+  revokeAppPassword<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerRevokeAppPassword.QueryParams,
+      ComAtprotoServerRevokeAppPassword.HandlerInput,
+      ComAtprotoServerRevokeAppPassword.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.revokeAppPassword' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateEmail<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoServerUpdateEmail.Handler<ExtractAuth<AV>>,
-      ComAtprotoServerUpdateEmail.HandlerReqCtx<ExtractAuth<AV>>
+  updateEmail<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoServerUpdateEmail.QueryParams,
+      ComAtprotoServerUpdateEmail.HandlerInput,
+      ComAtprotoServerUpdateEmail.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.server.updateEmail' // @ts-ignore
@@ -1083,176 +1141,191 @@ export class ComAtprotoSyncNS {
     this._server = server
   }
 
-  getBlob<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetBlob.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetBlob.HandlerReqCtx<ExtractAuth<AV>>
+  getBlob<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetBlob.QueryParams,
+      ComAtprotoSyncGetBlob.HandlerInput,
+      ComAtprotoSyncGetBlob.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getBlob' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getBlocks<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetBlocks.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetBlocks.HandlerReqCtx<ExtractAuth<AV>>
+  getBlocks<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetBlocks.QueryParams,
+      ComAtprotoSyncGetBlocks.HandlerInput,
+      ComAtprotoSyncGetBlocks.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getBlocks' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getCheckout<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetCheckout.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetCheckout.HandlerReqCtx<ExtractAuth<AV>>
+  getCheckout<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetCheckout.QueryParams,
+      ComAtprotoSyncGetCheckout.HandlerInput,
+      ComAtprotoSyncGetCheckout.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getCheckout' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getHead<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetHead.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetHead.HandlerReqCtx<ExtractAuth<AV>>
+  getHead<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetHead.QueryParams,
+      ComAtprotoSyncGetHead.HandlerInput,
+      ComAtprotoSyncGetHead.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getHead' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getHostStatus<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetHostStatus.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetHostStatus.HandlerReqCtx<ExtractAuth<AV>>
+  getHostStatus<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetHostStatus.QueryParams,
+      ComAtprotoSyncGetHostStatus.HandlerInput,
+      ComAtprotoSyncGetHostStatus.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getHostStatus' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getLatestCommit<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetLatestCommit.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetLatestCommit.HandlerReqCtx<ExtractAuth<AV>>
+  getLatestCommit<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetLatestCommit.QueryParams,
+      ComAtprotoSyncGetLatestCommit.HandlerInput,
+      ComAtprotoSyncGetLatestCommit.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getLatestCommit' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRecord<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetRecord.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetRecord.HandlerReqCtx<ExtractAuth<AV>>
+  getRecord<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetRecord.QueryParams,
+      ComAtprotoSyncGetRecord.HandlerInput,
+      ComAtprotoSyncGetRecord.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getRecord' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRepo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetRepo.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetRepo.HandlerReqCtx<ExtractAuth<AV>>
+  getRepo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetRepo.QueryParams,
+      ComAtprotoSyncGetRepo.HandlerInput,
+      ComAtprotoSyncGetRepo.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getRepo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRepoStatus<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncGetRepoStatus.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncGetRepoStatus.HandlerReqCtx<ExtractAuth<AV>>
+  getRepoStatus<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncGetRepoStatus.QueryParams,
+      ComAtprotoSyncGetRepoStatus.HandlerInput,
+      ComAtprotoSyncGetRepoStatus.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.getRepoStatus' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listBlobs<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncListBlobs.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncListBlobs.HandlerReqCtx<ExtractAuth<AV>>
+  listBlobs<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncListBlobs.QueryParams,
+      ComAtprotoSyncListBlobs.HandlerInput,
+      ComAtprotoSyncListBlobs.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.listBlobs' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listHosts<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncListHosts.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncListHosts.HandlerReqCtx<ExtractAuth<AV>>
+  listHosts<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncListHosts.QueryParams,
+      ComAtprotoSyncListHosts.HandlerInput,
+      ComAtprotoSyncListHosts.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.listHosts' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listRepos<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncListRepos.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncListRepos.HandlerReqCtx<ExtractAuth<AV>>
+  listRepos<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncListRepos.QueryParams,
+      ComAtprotoSyncListRepos.HandlerInput,
+      ComAtprotoSyncListRepos.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.listRepos' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listReposByCollection<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncListReposByCollection.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncListReposByCollection.HandlerReqCtx<ExtractAuth<AV>>
+  listReposByCollection<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncListReposByCollection.QueryParams,
+      ComAtprotoSyncListReposByCollection.HandlerInput,
+      ComAtprotoSyncListReposByCollection.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.listReposByCollection' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  notifyOfUpdate<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncNotifyOfUpdate.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncNotifyOfUpdate.HandlerReqCtx<ExtractAuth<AV>>
+  notifyOfUpdate<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncNotifyOfUpdate.QueryParams,
+      ComAtprotoSyncNotifyOfUpdate.HandlerInput,
+      ComAtprotoSyncNotifyOfUpdate.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.notifyOfUpdate' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  requestCrawl<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncRequestCrawl.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncRequestCrawl.HandlerReqCtx<ExtractAuth<AV>>
+  requestCrawl<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoSyncRequestCrawl.QueryParams,
+      ComAtprotoSyncRequestCrawl.HandlerInput,
+      ComAtprotoSyncRequestCrawl.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.requestCrawl' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  subscribeRepos<AV extends StreamAuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoSyncSubscribeRepos.Handler<ExtractAuth<AV>>,
-      ComAtprotoSyncSubscribeRepos.HandlerReqCtx<ExtractAuth<AV>>
+  subscribeRepos<A extends Auth = void>(
+    cfg: StreamConfigOrHandler<
+      A,
+      ComAtprotoSyncSubscribeRepos.QueryParams,
+      ComAtprotoSyncSubscribeRepos.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.sync.subscribeRepos' // @ts-ignore
@@ -1267,44 +1340,48 @@ export class ComAtprotoTempNS {
     this._server = server
   }
 
-  addReservedHandle<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoTempAddReservedHandle.Handler<ExtractAuth<AV>>,
-      ComAtprotoTempAddReservedHandle.HandlerReqCtx<ExtractAuth<AV>>
+  addReservedHandle<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoTempAddReservedHandle.QueryParams,
+      ComAtprotoTempAddReservedHandle.HandlerInput,
+      ComAtprotoTempAddReservedHandle.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.temp.addReservedHandle' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  checkSignupQueue<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoTempCheckSignupQueue.Handler<ExtractAuth<AV>>,
-      ComAtprotoTempCheckSignupQueue.HandlerReqCtx<ExtractAuth<AV>>
+  checkSignupQueue<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoTempCheckSignupQueue.QueryParams,
+      ComAtprotoTempCheckSignupQueue.HandlerInput,
+      ComAtprotoTempCheckSignupQueue.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.temp.checkSignupQueue' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  fetchLabels<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoTempFetchLabels.Handler<ExtractAuth<AV>>,
-      ComAtprotoTempFetchLabels.HandlerReqCtx<ExtractAuth<AV>>
+  fetchLabels<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoTempFetchLabels.QueryParams,
+      ComAtprotoTempFetchLabels.HandlerInput,
+      ComAtprotoTempFetchLabels.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.temp.fetchLabels' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  requestPhoneVerification<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ComAtprotoTempRequestPhoneVerification.Handler<ExtractAuth<AV>>,
-      ComAtprotoTempRequestPhoneVerification.HandlerReqCtx<ExtractAuth<AV>>
+  requestPhoneVerification<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ComAtprotoTempRequestPhoneVerification.QueryParams,
+      ComAtprotoTempRequestPhoneVerification.HandlerInput,
+      ComAtprotoTempRequestPhoneVerification.HandlerOutput
     >,
   ) {
     const nsid = 'com.atproto.temp.requestPhoneVerification' // @ts-ignore
@@ -1355,77 +1432,84 @@ export class AppBskyActorNS {
     this._server = server
   }
 
-  getPreferences<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyActorGetPreferences.Handler<ExtractAuth<AV>>,
-      AppBskyActorGetPreferences.HandlerReqCtx<ExtractAuth<AV>>
+  getPreferences<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyActorGetPreferences.QueryParams,
+      AppBskyActorGetPreferences.HandlerInput,
+      AppBskyActorGetPreferences.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.actor.getPreferences' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getProfile<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyActorGetProfile.Handler<ExtractAuth<AV>>,
-      AppBskyActorGetProfile.HandlerReqCtx<ExtractAuth<AV>>
+  getProfile<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyActorGetProfile.QueryParams,
+      AppBskyActorGetProfile.HandlerInput,
+      AppBskyActorGetProfile.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.actor.getProfile' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getProfiles<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyActorGetProfiles.Handler<ExtractAuth<AV>>,
-      AppBskyActorGetProfiles.HandlerReqCtx<ExtractAuth<AV>>
+  getProfiles<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyActorGetProfiles.QueryParams,
+      AppBskyActorGetProfiles.HandlerInput,
+      AppBskyActorGetProfiles.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.actor.getProfiles' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestions<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyActorGetSuggestions.Handler<ExtractAuth<AV>>,
-      AppBskyActorGetSuggestions.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyActorGetSuggestions.QueryParams,
+      AppBskyActorGetSuggestions.HandlerInput,
+      AppBskyActorGetSuggestions.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.actor.getSuggestions' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  putPreferences<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyActorPutPreferences.Handler<ExtractAuth<AV>>,
-      AppBskyActorPutPreferences.HandlerReqCtx<ExtractAuth<AV>>
+  putPreferences<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyActorPutPreferences.QueryParams,
+      AppBskyActorPutPreferences.HandlerInput,
+      AppBskyActorPutPreferences.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.actor.putPreferences' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchActors<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyActorSearchActors.Handler<ExtractAuth<AV>>,
-      AppBskyActorSearchActors.HandlerReqCtx<ExtractAuth<AV>>
+  searchActors<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyActorSearchActors.QueryParams,
+      AppBskyActorSearchActors.HandlerInput,
+      AppBskyActorSearchActors.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.actor.searchActors' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchActorsTypeahead<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyActorSearchActorsTypeahead.Handler<ExtractAuth<AV>>,
-      AppBskyActorSearchActorsTypeahead.HandlerReqCtx<ExtractAuth<AV>>
+  searchActorsTypeahead<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyActorSearchActorsTypeahead.QueryParams,
+      AppBskyActorSearchActorsTypeahead.HandlerInput,
+      AppBskyActorSearchActorsTypeahead.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.actor.searchActorsTypeahead' // @ts-ignore
@@ -1448,198 +1532,216 @@ export class AppBskyFeedNS {
     this._server = server
   }
 
-  describeFeedGenerator<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedDescribeFeedGenerator.Handler<ExtractAuth<AV>>,
-      AppBskyFeedDescribeFeedGenerator.HandlerReqCtx<ExtractAuth<AV>>
+  describeFeedGenerator<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedDescribeFeedGenerator.QueryParams,
+      AppBskyFeedDescribeFeedGenerator.HandlerInput,
+      AppBskyFeedDescribeFeedGenerator.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.describeFeedGenerator' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getActorFeeds<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetActorFeeds.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetActorFeeds.HandlerReqCtx<ExtractAuth<AV>>
+  getActorFeeds<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetActorFeeds.QueryParams,
+      AppBskyFeedGetActorFeeds.HandlerInput,
+      AppBskyFeedGetActorFeeds.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getActorFeeds' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getActorLikes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetActorLikes.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetActorLikes.HandlerReqCtx<ExtractAuth<AV>>
+  getActorLikes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetActorLikes.QueryParams,
+      AppBskyFeedGetActorLikes.HandlerInput,
+      AppBskyFeedGetActorLikes.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getActorLikes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getAuthorFeed<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetAuthorFeed.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetAuthorFeed.HandlerReqCtx<ExtractAuth<AV>>
+  getAuthorFeed<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetAuthorFeed.QueryParams,
+      AppBskyFeedGetAuthorFeed.HandlerInput,
+      AppBskyFeedGetAuthorFeed.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getAuthorFeed' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getFeed<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetFeed.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetFeed.HandlerReqCtx<ExtractAuth<AV>>
+  getFeed<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetFeed.QueryParams,
+      AppBskyFeedGetFeed.HandlerInput,
+      AppBskyFeedGetFeed.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getFeed' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getFeedGenerator<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetFeedGenerator.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetFeedGenerator.HandlerReqCtx<ExtractAuth<AV>>
+  getFeedGenerator<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetFeedGenerator.QueryParams,
+      AppBskyFeedGetFeedGenerator.HandlerInput,
+      AppBskyFeedGetFeedGenerator.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getFeedGenerator' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getFeedGenerators<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetFeedGenerators.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetFeedGenerators.HandlerReqCtx<ExtractAuth<AV>>
+  getFeedGenerators<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetFeedGenerators.QueryParams,
+      AppBskyFeedGetFeedGenerators.HandlerInput,
+      AppBskyFeedGetFeedGenerators.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getFeedGenerators' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getFeedSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetFeedSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetFeedSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  getFeedSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetFeedSkeleton.QueryParams,
+      AppBskyFeedGetFeedSkeleton.HandlerInput,
+      AppBskyFeedGetFeedSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getFeedSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getLikes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetLikes.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetLikes.HandlerReqCtx<ExtractAuth<AV>>
+  getLikes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetLikes.QueryParams,
+      AppBskyFeedGetLikes.HandlerInput,
+      AppBskyFeedGetLikes.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getLikes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getListFeed<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetListFeed.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetListFeed.HandlerReqCtx<ExtractAuth<AV>>
+  getListFeed<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetListFeed.QueryParams,
+      AppBskyFeedGetListFeed.HandlerInput,
+      AppBskyFeedGetListFeed.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getListFeed' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getPostThread<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetPostThread.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetPostThread.HandlerReqCtx<ExtractAuth<AV>>
+  getPosts<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetPosts.QueryParams,
+      AppBskyFeedGetPosts.HandlerInput,
+      AppBskyFeedGetPosts.HandlerOutput
     >,
   ) {
-    const nsid = 'app.bsky.feed.getPostThread' // @ts-ignore
+    const nsid = 'app.bsky.feed.getPosts' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getPosts<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetPosts.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetPosts.HandlerReqCtx<ExtractAuth<AV>>
+  getPostThread<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetPostThread.QueryParams,
+      AppBskyFeedGetPostThread.HandlerInput,
+      AppBskyFeedGetPostThread.HandlerOutput
     >,
   ) {
-    const nsid = 'app.bsky.feed.getPosts' // @ts-ignore
+    const nsid = 'app.bsky.feed.getPostThread' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getQuotes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetQuotes.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetQuotes.HandlerReqCtx<ExtractAuth<AV>>
+  getQuotes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetQuotes.QueryParams,
+      AppBskyFeedGetQuotes.HandlerInput,
+      AppBskyFeedGetQuotes.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getQuotes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRepostedBy<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetRepostedBy.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetRepostedBy.HandlerReqCtx<ExtractAuth<AV>>
+  getRepostedBy<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetRepostedBy.QueryParams,
+      AppBskyFeedGetRepostedBy.HandlerInput,
+      AppBskyFeedGetRepostedBy.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getRepostedBy' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedFeeds<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetSuggestedFeeds.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetSuggestedFeeds.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestedFeeds<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetSuggestedFeeds.QueryParams,
+      AppBskyFeedGetSuggestedFeeds.HandlerInput,
+      AppBskyFeedGetSuggestedFeeds.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getSuggestedFeeds' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getTimeline<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedGetTimeline.Handler<ExtractAuth<AV>>,
-      AppBskyFeedGetTimeline.HandlerReqCtx<ExtractAuth<AV>>
+  getTimeline<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedGetTimeline.QueryParams,
+      AppBskyFeedGetTimeline.HandlerInput,
+      AppBskyFeedGetTimeline.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.getTimeline' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchPosts<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedSearchPosts.Handler<ExtractAuth<AV>>,
-      AppBskyFeedSearchPosts.HandlerReqCtx<ExtractAuth<AV>>
+  searchPosts<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedSearchPosts.QueryParams,
+      AppBskyFeedSearchPosts.HandlerInput,
+      AppBskyFeedSearchPosts.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.searchPosts' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  sendInteractions<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyFeedSendInteractions.Handler<ExtractAuth<AV>>,
-      AppBskyFeedSendInteractions.HandlerReqCtx<ExtractAuth<AV>>
+  sendInteractions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyFeedSendInteractions.QueryParams,
+      AppBskyFeedSendInteractions.HandlerInput,
+      AppBskyFeedSendInteractions.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.feed.sendInteractions' // @ts-ignore
@@ -1654,231 +1756,252 @@ export class AppBskyGraphNS {
     this._server = server
   }
 
-  getActorStarterPacks<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetActorStarterPacks.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetActorStarterPacks.HandlerReqCtx<ExtractAuth<AV>>
+  getActorStarterPacks<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetActorStarterPacks.QueryParams,
+      AppBskyGraphGetActorStarterPacks.HandlerInput,
+      AppBskyGraphGetActorStarterPacks.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getActorStarterPacks' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getBlocks<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetBlocks.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetBlocks.HandlerReqCtx<ExtractAuth<AV>>
+  getBlocks<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetBlocks.QueryParams,
+      AppBskyGraphGetBlocks.HandlerInput,
+      AppBskyGraphGetBlocks.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getBlocks' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getFollowers<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetFollowers.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetFollowers.HandlerReqCtx<ExtractAuth<AV>>
+  getFollowers<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetFollowers.QueryParams,
+      AppBskyGraphGetFollowers.HandlerInput,
+      AppBskyGraphGetFollowers.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getFollowers' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getFollows<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetFollows.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetFollows.HandlerReqCtx<ExtractAuth<AV>>
+  getFollows<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetFollows.QueryParams,
+      AppBskyGraphGetFollows.HandlerInput,
+      AppBskyGraphGetFollows.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getFollows' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getKnownFollowers<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetKnownFollowers.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetKnownFollowers.HandlerReqCtx<ExtractAuth<AV>>
+  getKnownFollowers<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetKnownFollowers.QueryParams,
+      AppBskyGraphGetKnownFollowers.HandlerInput,
+      AppBskyGraphGetKnownFollowers.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getKnownFollowers' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getList<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetList.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetList.HandlerReqCtx<ExtractAuth<AV>>
+  getList<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetList.QueryParams,
+      AppBskyGraphGetList.HandlerInput,
+      AppBskyGraphGetList.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getList' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getListBlocks<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetListBlocks.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetListBlocks.HandlerReqCtx<ExtractAuth<AV>>
+  getListBlocks<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetListBlocks.QueryParams,
+      AppBskyGraphGetListBlocks.HandlerInput,
+      AppBskyGraphGetListBlocks.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getListBlocks' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getListMutes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetListMutes.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetListMutes.HandlerReqCtx<ExtractAuth<AV>>
+  getListMutes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetListMutes.QueryParams,
+      AppBskyGraphGetListMutes.HandlerInput,
+      AppBskyGraphGetListMutes.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getListMutes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getLists<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetLists.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetLists.HandlerReqCtx<ExtractAuth<AV>>
+  getLists<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetLists.QueryParams,
+      AppBskyGraphGetLists.HandlerInput,
+      AppBskyGraphGetLists.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getLists' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getMutes<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetMutes.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetMutes.HandlerReqCtx<ExtractAuth<AV>>
+  getMutes<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetMutes.QueryParams,
+      AppBskyGraphGetMutes.HandlerInput,
+      AppBskyGraphGetMutes.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getMutes' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRelationships<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetRelationships.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetRelationships.HandlerReqCtx<ExtractAuth<AV>>
+  getRelationships<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetRelationships.QueryParams,
+      AppBskyGraphGetRelationships.HandlerInput,
+      AppBskyGraphGetRelationships.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getRelationships' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getStarterPack<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetStarterPack.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetStarterPack.HandlerReqCtx<ExtractAuth<AV>>
+  getStarterPack<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetStarterPack.QueryParams,
+      AppBskyGraphGetStarterPack.HandlerInput,
+      AppBskyGraphGetStarterPack.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getStarterPack' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getStarterPacks<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetStarterPacks.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetStarterPacks.HandlerReqCtx<ExtractAuth<AV>>
+  getStarterPacks<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetStarterPacks.QueryParams,
+      AppBskyGraphGetStarterPacks.HandlerInput,
+      AppBskyGraphGetStarterPacks.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getStarterPacks' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedFollowsByActor<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphGetSuggestedFollowsByActor.Handler<ExtractAuth<AV>>,
-      AppBskyGraphGetSuggestedFollowsByActor.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestedFollowsByActor<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphGetSuggestedFollowsByActor.QueryParams,
+      AppBskyGraphGetSuggestedFollowsByActor.HandlerInput,
+      AppBskyGraphGetSuggestedFollowsByActor.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.getSuggestedFollowsByActor' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  muteActor<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphMuteActor.Handler<ExtractAuth<AV>>,
-      AppBskyGraphMuteActor.HandlerReqCtx<ExtractAuth<AV>>
+  muteActor<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphMuteActor.QueryParams,
+      AppBskyGraphMuteActor.HandlerInput,
+      AppBskyGraphMuteActor.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.muteActor' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  muteActorList<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphMuteActorList.Handler<ExtractAuth<AV>>,
-      AppBskyGraphMuteActorList.HandlerReqCtx<ExtractAuth<AV>>
+  muteActorList<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphMuteActorList.QueryParams,
+      AppBskyGraphMuteActorList.HandlerInput,
+      AppBskyGraphMuteActorList.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.muteActorList' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  muteThread<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphMuteThread.Handler<ExtractAuth<AV>>,
-      AppBskyGraphMuteThread.HandlerReqCtx<ExtractAuth<AV>>
+  muteThread<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphMuteThread.QueryParams,
+      AppBskyGraphMuteThread.HandlerInput,
+      AppBskyGraphMuteThread.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.muteThread' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchStarterPacks<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphSearchStarterPacks.Handler<ExtractAuth<AV>>,
-      AppBskyGraphSearchStarterPacks.HandlerReqCtx<ExtractAuth<AV>>
+  searchStarterPacks<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphSearchStarterPacks.QueryParams,
+      AppBskyGraphSearchStarterPacks.HandlerInput,
+      AppBskyGraphSearchStarterPacks.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.searchStarterPacks' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  unmuteActor<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphUnmuteActor.Handler<ExtractAuth<AV>>,
-      AppBskyGraphUnmuteActor.HandlerReqCtx<ExtractAuth<AV>>
+  unmuteActor<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphUnmuteActor.QueryParams,
+      AppBskyGraphUnmuteActor.HandlerInput,
+      AppBskyGraphUnmuteActor.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.unmuteActor' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  unmuteActorList<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphUnmuteActorList.Handler<ExtractAuth<AV>>,
-      AppBskyGraphUnmuteActorList.HandlerReqCtx<ExtractAuth<AV>>
+  unmuteActorList<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphUnmuteActorList.QueryParams,
+      AppBskyGraphUnmuteActorList.HandlerInput,
+      AppBskyGraphUnmuteActorList.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.unmuteActorList' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  unmuteThread<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyGraphUnmuteThread.Handler<ExtractAuth<AV>>,
-      AppBskyGraphUnmuteThread.HandlerReqCtx<ExtractAuth<AV>>
+  unmuteThread<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyGraphUnmuteThread.QueryParams,
+      AppBskyGraphUnmuteThread.HandlerInput,
+      AppBskyGraphUnmuteThread.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.graph.unmuteThread' // @ts-ignore
@@ -1893,11 +2016,12 @@ export class AppBskyLabelerNS {
     this._server = server
   }
 
-  getServices<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyLabelerGetServices.Handler<ExtractAuth<AV>>,
-      AppBskyLabelerGetServices.HandlerReqCtx<ExtractAuth<AV>>
+  getServices<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyLabelerGetServices.QueryParams,
+      AppBskyLabelerGetServices.HandlerInput,
+      AppBskyLabelerGetServices.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.labeler.getServices' // @ts-ignore
@@ -1912,101 +2036,108 @@ export class AppBskyNotificationNS {
     this._server = server
   }
 
-  getPreferences<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationGetPreferences.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationGetPreferences.HandlerReqCtx<ExtractAuth<AV>>
+  getPreferences<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationGetPreferences.QueryParams,
+      AppBskyNotificationGetPreferences.HandlerInput,
+      AppBskyNotificationGetPreferences.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.getPreferences' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getUnreadCount<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationGetUnreadCount.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationGetUnreadCount.HandlerReqCtx<ExtractAuth<AV>>
+  getUnreadCount<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationGetUnreadCount.QueryParams,
+      AppBskyNotificationGetUnreadCount.HandlerInput,
+      AppBskyNotificationGetUnreadCount.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.getUnreadCount' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listActivitySubscriptions<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationListActivitySubscriptions.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationListActivitySubscriptions.HandlerReqCtx<
-        ExtractAuth<AV>
-      >
+  listActivitySubscriptions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationListActivitySubscriptions.QueryParams,
+      AppBskyNotificationListActivitySubscriptions.HandlerInput,
+      AppBskyNotificationListActivitySubscriptions.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.listActivitySubscriptions' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listNotifications<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationListNotifications.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationListNotifications.HandlerReqCtx<ExtractAuth<AV>>
+  listNotifications<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationListNotifications.QueryParams,
+      AppBskyNotificationListNotifications.HandlerInput,
+      AppBskyNotificationListNotifications.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.listNotifications' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  putActivitySubscription<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationPutActivitySubscription.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationPutActivitySubscription.HandlerReqCtx<ExtractAuth<AV>>
+  putActivitySubscription<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationPutActivitySubscription.QueryParams,
+      AppBskyNotificationPutActivitySubscription.HandlerInput,
+      AppBskyNotificationPutActivitySubscription.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.putActivitySubscription' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  putPreferences<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationPutPreferences.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationPutPreferences.HandlerReqCtx<ExtractAuth<AV>>
+  putPreferences<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationPutPreferences.QueryParams,
+      AppBskyNotificationPutPreferences.HandlerInput,
+      AppBskyNotificationPutPreferences.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.putPreferences' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  putPreferencesV2<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationPutPreferencesV2.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationPutPreferencesV2.HandlerReqCtx<ExtractAuth<AV>>
+  putPreferencesV2<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationPutPreferencesV2.QueryParams,
+      AppBskyNotificationPutPreferencesV2.HandlerInput,
+      AppBskyNotificationPutPreferencesV2.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.putPreferencesV2' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  registerPush<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationRegisterPush.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationRegisterPush.HandlerReqCtx<ExtractAuth<AV>>
+  registerPush<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationRegisterPush.QueryParams,
+      AppBskyNotificationRegisterPush.HandlerInput,
+      AppBskyNotificationRegisterPush.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.registerPush' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateSeen<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyNotificationUpdateSeen.Handler<ExtractAuth<AV>>,
-      AppBskyNotificationUpdateSeen.HandlerReqCtx<ExtractAuth<AV>>
+  updateSeen<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyNotificationUpdateSeen.QueryParams,
+      AppBskyNotificationUpdateSeen.HandlerInput,
+      AppBskyNotificationUpdateSeen.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.notification.updateSeen' // @ts-ignore
@@ -2029,200 +2160,216 @@ export class AppBskyUnspeccedNS {
     this._server = server
   }
 
-  getConfig<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetConfig.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetConfig.HandlerReqCtx<ExtractAuth<AV>>
+  getConfig<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetConfig.QueryParams,
+      AppBskyUnspeccedGetConfig.HandlerInput,
+      AppBskyUnspeccedGetConfig.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getConfig' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getPopularFeedGenerators<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetPopularFeedGenerators.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetPopularFeedGenerators.HandlerReqCtx<ExtractAuth<AV>>
+  getPopularFeedGenerators<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetPopularFeedGenerators.QueryParams,
+      AppBskyUnspeccedGetPopularFeedGenerators.HandlerInput,
+      AppBskyUnspeccedGetPopularFeedGenerators.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getPopularFeedGenerators' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getPostThreadOtherV2<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetPostThreadOtherV2.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetPostThreadOtherV2.HandlerReqCtx<ExtractAuth<AV>>
+  getPostThreadOtherV2<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetPostThreadOtherV2.QueryParams,
+      AppBskyUnspeccedGetPostThreadOtherV2.HandlerInput,
+      AppBskyUnspeccedGetPostThreadOtherV2.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getPostThreadOtherV2' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getPostThreadV2<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetPostThreadV2.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetPostThreadV2.HandlerReqCtx<ExtractAuth<AV>>
+  getPostThreadV2<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetPostThreadV2.QueryParams,
+      AppBskyUnspeccedGetPostThreadV2.HandlerInput,
+      AppBskyUnspeccedGetPostThreadV2.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getPostThreadV2' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedFeeds<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetSuggestedFeeds.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetSuggestedFeeds.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestedFeeds<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetSuggestedFeeds.QueryParams,
+      AppBskyUnspeccedGetSuggestedFeeds.HandlerInput,
+      AppBskyUnspeccedGetSuggestedFeeds.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getSuggestedFeeds' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedFeedsSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetSuggestedFeedsSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetSuggestedFeedsSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestedFeedsSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetSuggestedFeedsSkeleton.QueryParams,
+      AppBskyUnspeccedGetSuggestedFeedsSkeleton.HandlerInput,
+      AppBskyUnspeccedGetSuggestedFeedsSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getSuggestedFeedsSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedStarterPacks<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetSuggestedStarterPacks.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetSuggestedStarterPacks.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestedStarterPacks<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetSuggestedStarterPacks.QueryParams,
+      AppBskyUnspeccedGetSuggestedStarterPacks.HandlerInput,
+      AppBskyUnspeccedGetSuggestedStarterPacks.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getSuggestedStarterPacks' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedStarterPacksSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.HandlerReqCtx<
-        ExtractAuth<AV>
-      >
+  getSuggestedStarterPacksSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.QueryParams,
+      AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.HandlerInput,
+      AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getSuggestedStarterPacksSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedUsers<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetSuggestedUsers.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetSuggestedUsers.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestedUsers<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetSuggestedUsers.QueryParams,
+      AppBskyUnspeccedGetSuggestedUsers.HandlerInput,
+      AppBskyUnspeccedGetSuggestedUsers.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getSuggestedUsers' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestedUsersSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetSuggestedUsersSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetSuggestedUsersSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestedUsersSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetSuggestedUsersSkeleton.QueryParams,
+      AppBskyUnspeccedGetSuggestedUsersSkeleton.HandlerInput,
+      AppBskyUnspeccedGetSuggestedUsersSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getSuggestedUsersSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSuggestionsSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetSuggestionsSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetSuggestionsSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  getSuggestionsSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetSuggestionsSkeleton.QueryParams,
+      AppBskyUnspeccedGetSuggestionsSkeleton.HandlerInput,
+      AppBskyUnspeccedGetSuggestionsSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getSuggestionsSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getTaggedSuggestions<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetTaggedSuggestions.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetTaggedSuggestions.HandlerReqCtx<ExtractAuth<AV>>
+  getTaggedSuggestions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetTaggedSuggestions.QueryParams,
+      AppBskyUnspeccedGetTaggedSuggestions.HandlerInput,
+      AppBskyUnspeccedGetTaggedSuggestions.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getTaggedSuggestions' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getTrendingTopics<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetTrendingTopics.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetTrendingTopics.HandlerReqCtx<ExtractAuth<AV>>
+  getTrendingTopics<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetTrendingTopics.QueryParams,
+      AppBskyUnspeccedGetTrendingTopics.HandlerInput,
+      AppBskyUnspeccedGetTrendingTopics.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getTrendingTopics' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getTrends<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetTrends.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetTrends.HandlerReqCtx<ExtractAuth<AV>>
+  getTrends<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetTrends.QueryParams,
+      AppBskyUnspeccedGetTrends.HandlerInput,
+      AppBskyUnspeccedGetTrends.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getTrends' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getTrendsSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedGetTrendsSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedGetTrendsSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  getTrendsSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedGetTrendsSkeleton.QueryParams,
+      AppBskyUnspeccedGetTrendsSkeleton.HandlerInput,
+      AppBskyUnspeccedGetTrendsSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.getTrendsSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchActorsSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedSearchActorsSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedSearchActorsSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  searchActorsSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedSearchActorsSkeleton.QueryParams,
+      AppBskyUnspeccedSearchActorsSkeleton.HandlerInput,
+      AppBskyUnspeccedSearchActorsSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.searchActorsSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchPostsSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedSearchPostsSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedSearchPostsSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  searchPostsSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedSearchPostsSkeleton.QueryParams,
+      AppBskyUnspeccedSearchPostsSkeleton.HandlerInput,
+      AppBskyUnspeccedSearchPostsSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.searchPostsSkeleton' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchStarterPacksSkeleton<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyUnspeccedSearchStarterPacksSkeleton.Handler<ExtractAuth<AV>>,
-      AppBskyUnspeccedSearchStarterPacksSkeleton.HandlerReqCtx<ExtractAuth<AV>>
+  searchStarterPacksSkeleton<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyUnspeccedSearchStarterPacksSkeleton.QueryParams,
+      AppBskyUnspeccedSearchStarterPacksSkeleton.HandlerInput,
+      AppBskyUnspeccedSearchStarterPacksSkeleton.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.unspecced.searchStarterPacksSkeleton' // @ts-ignore
@@ -2237,33 +2384,36 @@ export class AppBskyVideoNS {
     this._server = server
   }
 
-  getJobStatus<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyVideoGetJobStatus.Handler<ExtractAuth<AV>>,
-      AppBskyVideoGetJobStatus.HandlerReqCtx<ExtractAuth<AV>>
+  getJobStatus<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyVideoGetJobStatus.QueryParams,
+      AppBskyVideoGetJobStatus.HandlerInput,
+      AppBskyVideoGetJobStatus.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.video.getJobStatus' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getUploadLimits<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyVideoGetUploadLimits.Handler<ExtractAuth<AV>>,
-      AppBskyVideoGetUploadLimits.HandlerReqCtx<ExtractAuth<AV>>
+  getUploadLimits<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyVideoGetUploadLimits.QueryParams,
+      AppBskyVideoGetUploadLimits.HandlerInput,
+      AppBskyVideoGetUploadLimits.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.video.getUploadLimits' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  uploadVideo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppBskyVideoUploadVideo.Handler<ExtractAuth<AV>>,
-      AppBskyVideoUploadVideo.HandlerReqCtx<ExtractAuth<AV>>
+  uploadVideo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      AppBskyVideoUploadVideo.QueryParams,
+      AppBskyVideoUploadVideo.HandlerInput,
+      AppBskyVideoUploadVideo.HandlerOutput
     >,
   ) {
     const nsid = 'app.bsky.video.uploadVideo' // @ts-ignore
@@ -2302,22 +2452,24 @@ export class ChatBskyActorNS {
     this._server = server
   }
 
-  deleteAccount<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyActorDeleteAccount.Handler<ExtractAuth<AV>>,
-      ChatBskyActorDeleteAccount.HandlerReqCtx<ExtractAuth<AV>>
+  deleteAccount<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyActorDeleteAccount.QueryParams,
+      ChatBskyActorDeleteAccount.HandlerInput,
+      ChatBskyActorDeleteAccount.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.actor.deleteAccount' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  exportAccountData<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyActorExportAccountData.Handler<ExtractAuth<AV>>,
-      ChatBskyActorExportAccountData.HandlerReqCtx<ExtractAuth<AV>>
+  exportAccountData<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyActorExportAccountData.QueryParams,
+      ChatBskyActorExportAccountData.HandlerInput,
+      ChatBskyActorExportAccountData.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.actor.exportAccountData' // @ts-ignore
@@ -2332,187 +2484,204 @@ export class ChatBskyConvoNS {
     this._server = server
   }
 
-  acceptConvo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoAcceptConvo.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoAcceptConvo.HandlerReqCtx<ExtractAuth<AV>>
+  acceptConvo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoAcceptConvo.QueryParams,
+      ChatBskyConvoAcceptConvo.HandlerInput,
+      ChatBskyConvoAcceptConvo.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.acceptConvo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  addReaction<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoAddReaction.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoAddReaction.HandlerReqCtx<ExtractAuth<AV>>
+  addReaction<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoAddReaction.QueryParams,
+      ChatBskyConvoAddReaction.HandlerInput,
+      ChatBskyConvoAddReaction.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.addReaction' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteMessageForSelf<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoDeleteMessageForSelf.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoDeleteMessageForSelf.HandlerReqCtx<ExtractAuth<AV>>
+  deleteMessageForSelf<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoDeleteMessageForSelf.QueryParams,
+      ChatBskyConvoDeleteMessageForSelf.HandlerInput,
+      ChatBskyConvoDeleteMessageForSelf.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.deleteMessageForSelf' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getConvo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoGetConvo.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoGetConvo.HandlerReqCtx<ExtractAuth<AV>>
+  getConvo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoGetConvo.QueryParams,
+      ChatBskyConvoGetConvo.HandlerInput,
+      ChatBskyConvoGetConvo.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.getConvo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getConvoAvailability<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoGetConvoAvailability.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoGetConvoAvailability.HandlerReqCtx<ExtractAuth<AV>>
+  getConvoAvailability<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoGetConvoAvailability.QueryParams,
+      ChatBskyConvoGetConvoAvailability.HandlerInput,
+      ChatBskyConvoGetConvoAvailability.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.getConvoAvailability' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getConvoForMembers<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoGetConvoForMembers.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoGetConvoForMembers.HandlerReqCtx<ExtractAuth<AV>>
+  getConvoForMembers<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoGetConvoForMembers.QueryParams,
+      ChatBskyConvoGetConvoForMembers.HandlerInput,
+      ChatBskyConvoGetConvoForMembers.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.getConvoForMembers' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getLog<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoGetLog.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoGetLog.HandlerReqCtx<ExtractAuth<AV>>
+  getLog<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoGetLog.QueryParams,
+      ChatBskyConvoGetLog.HandlerInput,
+      ChatBskyConvoGetLog.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.getLog' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getMessages<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoGetMessages.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoGetMessages.HandlerReqCtx<ExtractAuth<AV>>
+  getMessages<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoGetMessages.QueryParams,
+      ChatBskyConvoGetMessages.HandlerInput,
+      ChatBskyConvoGetMessages.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.getMessages' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  leaveConvo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoLeaveConvo.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoLeaveConvo.HandlerReqCtx<ExtractAuth<AV>>
+  leaveConvo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoLeaveConvo.QueryParams,
+      ChatBskyConvoLeaveConvo.HandlerInput,
+      ChatBskyConvoLeaveConvo.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.leaveConvo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listConvos<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoListConvos.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoListConvos.HandlerReqCtx<ExtractAuth<AV>>
+  listConvos<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoListConvos.QueryParams,
+      ChatBskyConvoListConvos.HandlerInput,
+      ChatBskyConvoListConvos.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.listConvos' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  muteConvo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoMuteConvo.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoMuteConvo.HandlerReqCtx<ExtractAuth<AV>>
+  muteConvo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoMuteConvo.QueryParams,
+      ChatBskyConvoMuteConvo.HandlerInput,
+      ChatBskyConvoMuteConvo.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.muteConvo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  removeReaction<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoRemoveReaction.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoRemoveReaction.HandlerReqCtx<ExtractAuth<AV>>
+  removeReaction<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoRemoveReaction.QueryParams,
+      ChatBskyConvoRemoveReaction.HandlerInput,
+      ChatBskyConvoRemoveReaction.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.removeReaction' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  sendMessage<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoSendMessage.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoSendMessage.HandlerReqCtx<ExtractAuth<AV>>
+  sendMessage<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoSendMessage.QueryParams,
+      ChatBskyConvoSendMessage.HandlerInput,
+      ChatBskyConvoSendMessage.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.sendMessage' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  sendMessageBatch<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoSendMessageBatch.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoSendMessageBatch.HandlerReqCtx<ExtractAuth<AV>>
+  sendMessageBatch<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoSendMessageBatch.QueryParams,
+      ChatBskyConvoSendMessageBatch.HandlerInput,
+      ChatBskyConvoSendMessageBatch.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.sendMessageBatch' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  unmuteConvo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoUnmuteConvo.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoUnmuteConvo.HandlerReqCtx<ExtractAuth<AV>>
+  unmuteConvo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoUnmuteConvo.QueryParams,
+      ChatBskyConvoUnmuteConvo.HandlerInput,
+      ChatBskyConvoUnmuteConvo.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.unmuteConvo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateAllRead<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoUpdateAllRead.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoUpdateAllRead.HandlerReqCtx<ExtractAuth<AV>>
+  updateAllRead<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoUpdateAllRead.QueryParams,
+      ChatBskyConvoUpdateAllRead.HandlerInput,
+      ChatBskyConvoUpdateAllRead.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.updateAllRead' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateRead<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyConvoUpdateRead.Handler<ExtractAuth<AV>>,
-      ChatBskyConvoUpdateRead.HandlerReqCtx<ExtractAuth<AV>>
+  updateRead<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyConvoUpdateRead.QueryParams,
+      ChatBskyConvoUpdateRead.HandlerInput,
+      ChatBskyConvoUpdateRead.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.convo.updateRead' // @ts-ignore
@@ -2527,33 +2696,36 @@ export class ChatBskyModerationNS {
     this._server = server
   }
 
-  getActorMetadata<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyModerationGetActorMetadata.Handler<ExtractAuth<AV>>,
-      ChatBskyModerationGetActorMetadata.HandlerReqCtx<ExtractAuth<AV>>
+  getActorMetadata<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyModerationGetActorMetadata.QueryParams,
+      ChatBskyModerationGetActorMetadata.HandlerInput,
+      ChatBskyModerationGetActorMetadata.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.moderation.getActorMetadata' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getMessageContext<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyModerationGetMessageContext.Handler<ExtractAuth<AV>>,
-      ChatBskyModerationGetMessageContext.HandlerReqCtx<ExtractAuth<AV>>
+  getMessageContext<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyModerationGetMessageContext.QueryParams,
+      ChatBskyModerationGetMessageContext.HandlerInput,
+      ChatBskyModerationGetMessageContext.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.moderation.getMessageContext' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateActorAccess<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ChatBskyModerationUpdateActorAccess.Handler<ExtractAuth<AV>>,
-      ChatBskyModerationUpdateActorAccess.HandlerReqCtx<ExtractAuth<AV>>
+  updateActorAccess<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ChatBskyModerationUpdateActorAccess.QueryParams,
+      ChatBskyModerationUpdateActorAccess.HandlerInput,
+      ChatBskyModerationUpdateActorAccess.HandlerOutput
     >,
   ) {
     const nsid = 'chat.bsky.moderation.updateActorAccess' // @ts-ignore
@@ -2606,44 +2778,48 @@ export class ToolsOzoneCommunicationNS {
     this._server = server
   }
 
-  createTemplate<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneCommunicationCreateTemplate.Handler<ExtractAuth<AV>>,
-      ToolsOzoneCommunicationCreateTemplate.HandlerReqCtx<ExtractAuth<AV>>
+  createTemplate<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneCommunicationCreateTemplate.QueryParams,
+      ToolsOzoneCommunicationCreateTemplate.HandlerInput,
+      ToolsOzoneCommunicationCreateTemplate.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.communication.createTemplate' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteTemplate<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneCommunicationDeleteTemplate.Handler<ExtractAuth<AV>>,
-      ToolsOzoneCommunicationDeleteTemplate.HandlerReqCtx<ExtractAuth<AV>>
+  deleteTemplate<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneCommunicationDeleteTemplate.QueryParams,
+      ToolsOzoneCommunicationDeleteTemplate.HandlerInput,
+      ToolsOzoneCommunicationDeleteTemplate.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.communication.deleteTemplate' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listTemplates<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneCommunicationListTemplates.Handler<ExtractAuth<AV>>,
-      ToolsOzoneCommunicationListTemplates.HandlerReqCtx<ExtractAuth<AV>>
+  listTemplates<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneCommunicationListTemplates.QueryParams,
+      ToolsOzoneCommunicationListTemplates.HandlerInput,
+      ToolsOzoneCommunicationListTemplates.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.communication.listTemplates' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateTemplate<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneCommunicationUpdateTemplate.Handler<ExtractAuth<AV>>,
-      ToolsOzoneCommunicationUpdateTemplate.HandlerReqCtx<ExtractAuth<AV>>
+  updateTemplate<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneCommunicationUpdateTemplate.QueryParams,
+      ToolsOzoneCommunicationUpdateTemplate.HandlerInput,
+      ToolsOzoneCommunicationUpdateTemplate.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.communication.updateTemplate' // @ts-ignore
@@ -2658,11 +2834,12 @@ export class ToolsOzoneHostingNS {
     this._server = server
   }
 
-  getAccountHistory<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneHostingGetAccountHistory.Handler<ExtractAuth<AV>>,
-      ToolsOzoneHostingGetAccountHistory.HandlerReqCtx<ExtractAuth<AV>>
+  getAccountHistory<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneHostingGetAccountHistory.QueryParams,
+      ToolsOzoneHostingGetAccountHistory.HandlerInput,
+      ToolsOzoneHostingGetAccountHistory.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.hosting.getAccountHistory' // @ts-ignore
@@ -2677,121 +2854,132 @@ export class ToolsOzoneModerationNS {
     this._server = server
   }
 
-  emitEvent<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationEmitEvent.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationEmitEvent.HandlerReqCtx<ExtractAuth<AV>>
+  emitEvent<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationEmitEvent.QueryParams,
+      ToolsOzoneModerationEmitEvent.HandlerInput,
+      ToolsOzoneModerationEmitEvent.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.emitEvent' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getEvent<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationGetEvent.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationGetEvent.HandlerReqCtx<ExtractAuth<AV>>
+  getEvent<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetEvent.QueryParams,
+      ToolsOzoneModerationGetEvent.HandlerInput,
+      ToolsOzoneModerationGetEvent.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.getEvent' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRecord<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationGetRecord.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationGetRecord.HandlerReqCtx<ExtractAuth<AV>>
+  getRecord<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetRecord.QueryParams,
+      ToolsOzoneModerationGetRecord.HandlerInput,
+      ToolsOzoneModerationGetRecord.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.getRecord' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRecords<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationGetRecords.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationGetRecords.HandlerReqCtx<ExtractAuth<AV>>
+  getRecords<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetRecords.QueryParams,
+      ToolsOzoneModerationGetRecords.HandlerInput,
+      ToolsOzoneModerationGetRecords.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.getRecords' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRepo<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationGetRepo.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationGetRepo.HandlerReqCtx<ExtractAuth<AV>>
+  getRepo<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetRepo.QueryParams,
+      ToolsOzoneModerationGetRepo.HandlerInput,
+      ToolsOzoneModerationGetRepo.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.getRepo' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getReporterStats<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationGetReporterStats.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationGetReporterStats.HandlerReqCtx<ExtractAuth<AV>>
+  getReporterStats<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetReporterStats.QueryParams,
+      ToolsOzoneModerationGetReporterStats.HandlerInput,
+      ToolsOzoneModerationGetReporterStats.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.getReporterStats' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getRepos<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationGetRepos.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationGetRepos.HandlerReqCtx<ExtractAuth<AV>>
+  getRepos<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetRepos.QueryParams,
+      ToolsOzoneModerationGetRepos.HandlerInput,
+      ToolsOzoneModerationGetRepos.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.getRepos' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getSubjects<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationGetSubjects.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationGetSubjects.HandlerReqCtx<ExtractAuth<AV>>
+  getSubjects<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationGetSubjects.QueryParams,
+      ToolsOzoneModerationGetSubjects.HandlerInput,
+      ToolsOzoneModerationGetSubjects.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.getSubjects' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  queryEvents<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationQueryEvents.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationQueryEvents.HandlerReqCtx<ExtractAuth<AV>>
+  queryEvents<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationQueryEvents.QueryParams,
+      ToolsOzoneModerationQueryEvents.HandlerInput,
+      ToolsOzoneModerationQueryEvents.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.queryEvents' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  queryStatuses<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationQueryStatuses.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationQueryStatuses.HandlerReqCtx<ExtractAuth<AV>>
+  queryStatuses<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationQueryStatuses.QueryParams,
+      ToolsOzoneModerationQueryStatuses.HandlerInput,
+      ToolsOzoneModerationQueryStatuses.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.queryStatuses' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchRepos<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneModerationSearchRepos.Handler<ExtractAuth<AV>>,
-      ToolsOzoneModerationSearchRepos.HandlerReqCtx<ExtractAuth<AV>>
+  searchRepos<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneModerationSearchRepos.QueryParams,
+      ToolsOzoneModerationSearchRepos.HandlerInput,
+      ToolsOzoneModerationSearchRepos.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.moderation.searchRepos' // @ts-ignore
@@ -2806,55 +2994,60 @@ export class ToolsOzoneSafelinkNS {
     this._server = server
   }
 
-  addRule<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSafelinkAddRule.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSafelinkAddRule.HandlerReqCtx<ExtractAuth<AV>>
+  addRule<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSafelinkAddRule.QueryParams,
+      ToolsOzoneSafelinkAddRule.HandlerInput,
+      ToolsOzoneSafelinkAddRule.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.safelink.addRule' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  queryEvents<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSafelinkQueryEvents.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSafelinkQueryEvents.HandlerReqCtx<ExtractAuth<AV>>
+  queryEvents<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSafelinkQueryEvents.QueryParams,
+      ToolsOzoneSafelinkQueryEvents.HandlerInput,
+      ToolsOzoneSafelinkQueryEvents.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.safelink.queryEvents' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  queryRules<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSafelinkQueryRules.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSafelinkQueryRules.HandlerReqCtx<ExtractAuth<AV>>
+  queryRules<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSafelinkQueryRules.QueryParams,
+      ToolsOzoneSafelinkQueryRules.HandlerInput,
+      ToolsOzoneSafelinkQueryRules.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.safelink.queryRules' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  removeRule<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSafelinkRemoveRule.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSafelinkRemoveRule.HandlerReqCtx<ExtractAuth<AV>>
+  removeRule<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSafelinkRemoveRule.QueryParams,
+      ToolsOzoneSafelinkRemoveRule.HandlerInput,
+      ToolsOzoneSafelinkRemoveRule.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.safelink.removeRule' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateRule<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSafelinkUpdateRule.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSafelinkUpdateRule.HandlerReqCtx<ExtractAuth<AV>>
+  updateRule<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSafelinkUpdateRule.QueryParams,
+      ToolsOzoneSafelinkUpdateRule.HandlerInput,
+      ToolsOzoneSafelinkUpdateRule.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.safelink.updateRule' // @ts-ignore
@@ -2869,11 +3062,12 @@ export class ToolsOzoneServerNS {
     this._server = server
   }
 
-  getConfig<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneServerGetConfig.Handler<ExtractAuth<AV>>,
-      ToolsOzoneServerGetConfig.HandlerReqCtx<ExtractAuth<AV>>
+  getConfig<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneServerGetConfig.QueryParams,
+      ToolsOzoneServerGetConfig.HandlerInput,
+      ToolsOzoneServerGetConfig.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.server.getConfig' // @ts-ignore
@@ -2888,66 +3082,72 @@ export class ToolsOzoneSetNS {
     this._server = server
   }
 
-  addValues<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSetAddValues.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSetAddValues.HandlerReqCtx<ExtractAuth<AV>>
+  addValues<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSetAddValues.QueryParams,
+      ToolsOzoneSetAddValues.HandlerInput,
+      ToolsOzoneSetAddValues.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.set.addValues' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteSet<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSetDeleteSet.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSetDeleteSet.HandlerReqCtx<ExtractAuth<AV>>
+  deleteSet<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSetDeleteSet.QueryParams,
+      ToolsOzoneSetDeleteSet.HandlerInput,
+      ToolsOzoneSetDeleteSet.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.set.deleteSet' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteValues<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSetDeleteValues.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSetDeleteValues.HandlerReqCtx<ExtractAuth<AV>>
+  deleteValues<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSetDeleteValues.QueryParams,
+      ToolsOzoneSetDeleteValues.HandlerInput,
+      ToolsOzoneSetDeleteValues.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.set.deleteValues' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  getValues<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSetGetValues.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSetGetValues.HandlerReqCtx<ExtractAuth<AV>>
+  getValues<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSetGetValues.QueryParams,
+      ToolsOzoneSetGetValues.HandlerInput,
+      ToolsOzoneSetGetValues.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.set.getValues' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  querySets<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSetQuerySets.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSetQuerySets.HandlerReqCtx<ExtractAuth<AV>>
+  querySets<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSetQuerySets.QueryParams,
+      ToolsOzoneSetQuerySets.HandlerInput,
+      ToolsOzoneSetQuerySets.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.set.querySets' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  upsertSet<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSetUpsertSet.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSetUpsertSet.HandlerReqCtx<ExtractAuth<AV>>
+  upsertSet<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSetUpsertSet.QueryParams,
+      ToolsOzoneSetUpsertSet.HandlerInput,
+      ToolsOzoneSetUpsertSet.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.set.upsertSet' // @ts-ignore
@@ -2962,33 +3162,36 @@ export class ToolsOzoneSettingNS {
     this._server = server
   }
 
-  listOptions<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSettingListOptions.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSettingListOptions.HandlerReqCtx<ExtractAuth<AV>>
+  listOptions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSettingListOptions.QueryParams,
+      ToolsOzoneSettingListOptions.HandlerInput,
+      ToolsOzoneSettingListOptions.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.setting.listOptions' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  removeOptions<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSettingRemoveOptions.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSettingRemoveOptions.HandlerReqCtx<ExtractAuth<AV>>
+  removeOptions<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSettingRemoveOptions.QueryParams,
+      ToolsOzoneSettingRemoveOptions.HandlerInput,
+      ToolsOzoneSettingRemoveOptions.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.setting.removeOptions' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  upsertOption<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSettingUpsertOption.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSettingUpsertOption.HandlerReqCtx<ExtractAuth<AV>>
+  upsertOption<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSettingUpsertOption.QueryParams,
+      ToolsOzoneSettingUpsertOption.HandlerInput,
+      ToolsOzoneSettingUpsertOption.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.setting.upsertOption' // @ts-ignore
@@ -3003,33 +3206,36 @@ export class ToolsOzoneSignatureNS {
     this._server = server
   }
 
-  findCorrelation<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSignatureFindCorrelation.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSignatureFindCorrelation.HandlerReqCtx<ExtractAuth<AV>>
+  findCorrelation<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSignatureFindCorrelation.QueryParams,
+      ToolsOzoneSignatureFindCorrelation.HandlerInput,
+      ToolsOzoneSignatureFindCorrelation.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.signature.findCorrelation' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  findRelatedAccounts<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSignatureFindRelatedAccounts.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSignatureFindRelatedAccounts.HandlerReqCtx<ExtractAuth<AV>>
+  findRelatedAccounts<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSignatureFindRelatedAccounts.QueryParams,
+      ToolsOzoneSignatureFindRelatedAccounts.HandlerInput,
+      ToolsOzoneSignatureFindRelatedAccounts.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.signature.findRelatedAccounts' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  searchAccounts<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneSignatureSearchAccounts.Handler<ExtractAuth<AV>>,
-      ToolsOzoneSignatureSearchAccounts.HandlerReqCtx<ExtractAuth<AV>>
+  searchAccounts<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneSignatureSearchAccounts.QueryParams,
+      ToolsOzoneSignatureSearchAccounts.HandlerInput,
+      ToolsOzoneSignatureSearchAccounts.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.signature.searchAccounts' // @ts-ignore
@@ -3044,44 +3250,48 @@ export class ToolsOzoneTeamNS {
     this._server = server
   }
 
-  addMember<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneTeamAddMember.Handler<ExtractAuth<AV>>,
-      ToolsOzoneTeamAddMember.HandlerReqCtx<ExtractAuth<AV>>
+  addMember<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneTeamAddMember.QueryParams,
+      ToolsOzoneTeamAddMember.HandlerInput,
+      ToolsOzoneTeamAddMember.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.team.addMember' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  deleteMember<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneTeamDeleteMember.Handler<ExtractAuth<AV>>,
-      ToolsOzoneTeamDeleteMember.HandlerReqCtx<ExtractAuth<AV>>
+  deleteMember<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneTeamDeleteMember.QueryParams,
+      ToolsOzoneTeamDeleteMember.HandlerInput,
+      ToolsOzoneTeamDeleteMember.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.team.deleteMember' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listMembers<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneTeamListMembers.Handler<ExtractAuth<AV>>,
-      ToolsOzoneTeamListMembers.HandlerReqCtx<ExtractAuth<AV>>
+  listMembers<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneTeamListMembers.QueryParams,
+      ToolsOzoneTeamListMembers.HandlerInput,
+      ToolsOzoneTeamListMembers.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.team.listMembers' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  updateMember<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneTeamUpdateMember.Handler<ExtractAuth<AV>>,
-      ToolsOzoneTeamUpdateMember.HandlerReqCtx<ExtractAuth<AV>>
+  updateMember<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneTeamUpdateMember.QueryParams,
+      ToolsOzoneTeamUpdateMember.HandlerInput,
+      ToolsOzoneTeamUpdateMember.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.team.updateMember' // @ts-ignore
@@ -3096,62 +3306,39 @@ export class ToolsOzoneVerificationNS {
     this._server = server
   }
 
-  grantVerifications<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneVerificationGrantVerifications.Handler<ExtractAuth<AV>>,
-      ToolsOzoneVerificationGrantVerifications.HandlerReqCtx<ExtractAuth<AV>>
+  grantVerifications<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneVerificationGrantVerifications.QueryParams,
+      ToolsOzoneVerificationGrantVerifications.HandlerInput,
+      ToolsOzoneVerificationGrantVerifications.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.verification.grantVerifications' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  listVerifications<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneVerificationListVerifications.Handler<ExtractAuth<AV>>,
-      ToolsOzoneVerificationListVerifications.HandlerReqCtx<ExtractAuth<AV>>
+  listVerifications<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneVerificationListVerifications.QueryParams,
+      ToolsOzoneVerificationListVerifications.HandlerInput,
+      ToolsOzoneVerificationListVerifications.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.verification.listVerifications' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 
-  revokeVerifications<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      ToolsOzoneVerificationRevokeVerifications.Handler<ExtractAuth<AV>>,
-      ToolsOzoneVerificationRevokeVerifications.HandlerReqCtx<ExtractAuth<AV>>
+  revokeVerifications<A extends Auth = void>(
+    cfg: MethodConfigOrHandler<
+      A,
+      ToolsOzoneVerificationRevokeVerifications.QueryParams,
+      ToolsOzoneVerificationRevokeVerifications.HandlerInput,
+      ToolsOzoneVerificationRevokeVerifications.HandlerOutput
     >,
   ) {
     const nsid = 'tools.ozone.verification.revokeVerifications' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 }
-
-type SharedRateLimitOpts<T> = {
-  name: string
-  calcKey?: (ctx: T) => string | null
-  calcPoints?: (ctx: T) => number
-}
-type RouteRateLimitOpts<T> = {
-  durationMs: number
-  points: number
-  calcKey?: (ctx: T) => string | null
-  calcPoints?: (ctx: T) => number
-}
-type HandlerOpts = { blobLimit?: number }
-type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>
-type ConfigOf<Auth, Handler, ReqCtx> =
-  | Handler
-  | {
-      auth?: Auth
-      opts?: HandlerOpts
-      rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]
-      handler: Handler
-    }
-type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract<
-  Awaited<ReturnType<AV>>,
-  { credentials: unknown }
->