@atproto/api 0.14.0-next.0 → 0.14.0-next.1

package/src/client/types/chat/bsky/convo/defs.ts

@@ -3,12 +3,18 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as AppBskyRichtextFacet from '../../../app/bsky/richtext/facet'
-import * as AppBskyEmbedRecord from '../../../app/bsky/embed/record'
-import * as ChatBskyActorDefs from '../actor/defs'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as AppBskyRichtextFacet from '../../../app/bsky/richtext/facet'
+import type * as AppBskyEmbedRecord from '../../../app/bsky/embed/record'
+import type * as ChatBskyActorDefs from '../actor/defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.defs'
 
 export interface MessageRef {
@@ -18,19 +24,18 @@ export interface MessageRef {
   messageId: string
 }
 
+const hashMessageRef = 'messageRef'
+
 export function isMessageRef<V>(v: V) {
-  return is$typed(v, id, 'messageRef')
+  return is$typed(v, id, hashMessageRef)
 }
 
-export function validateMessageRef(v: unknown) {
-  return lexicons.validate(
-    `${id}#messageRef`,
-    v,
-  ) as ValidationResult<MessageRef>
+export function validateMessageRef<V>(v: V) {
+  return validate<MessageRef & V>(v, id, hashMessageRef)
 }
 
-export function isValidMessageRef<V>(v: V): v is V & $Typed<MessageRef> {
-  return isMessageRef(v) && validateMessageRef(v).success
+export function isValidMessageRef<V>(v: V) {
+  return isValid<MessageRef>(v, id, hashMessageRef)
 }
 
 export interface MessageInput {
@@ -41,19 +46,18 @@ export interface MessageInput {
   embed?: $Typed<AppBskyEmbedRecord.Main> | { $type: string }
 }
 
+const hashMessageInput = 'messageInput'
+
 export function isMessageInput<V>(v: V) {
-  return is$typed(v, id, 'messageInput')
+  return is$typed(v, id, hashMessageInput)
 }
 
-export function validateMessageInput(v: unknown) {
-  return lexicons.validate(
-    `${id}#messageInput`,
-    v,
-  ) as ValidationResult<MessageInput>
+export function validateMessageInput<V>(v: V) {
+  return validate<MessageInput & V>(v, id, hashMessageInput)
 }
 
-export function isValidMessageInput<V>(v: V): v is V & $Typed<MessageInput> {
-  return isMessageInput(v) && validateMessageInput(v).success
+export function isValidMessageInput<V>(v: V) {
+  return isValid<MessageInput>(v, id, hashMessageInput)
 }
 
 export interface MessageView {
@@ -68,19 +72,18 @@ export interface MessageView {
   sentAt: string
 }
 
+const hashMessageView = 'messageView'
+
 export function isMessageView<V>(v: V) {
-  return is$typed(v, id, 'messageView')
+  return is$typed(v, id, hashMessageView)
 }
 
-export function validateMessageView(v: unknown) {
-  return lexicons.validate(
-    `${id}#messageView`,
-    v,
-  ) as ValidationResult<MessageView>
+export function validateMessageView<V>(v: V) {
+  return validate<MessageView & V>(v, id, hashMessageView)
 }
 
-export function isValidMessageView<V>(v: V): v is V & $Typed<MessageView> {
-  return isMessageView(v) && validateMessageView(v).success
+export function isValidMessageView<V>(v: V) {
+  return isValid<MessageView>(v, id, hashMessageView)
 }
 
 export interface DeletedMessageView {
@@ -91,21 +94,18 @@ export interface DeletedMessageView {
   sentAt: string
 }
 
+const hashDeletedMessageView = 'deletedMessageView'
+
 export function isDeletedMessageView<V>(v: V) {
-  return is$typed(v, id, 'deletedMessageView')
+  return is$typed(v, id, hashDeletedMessageView)
 }
 
-export function validateDeletedMessageView(v: unknown) {
-  return lexicons.validate(
-    `${id}#deletedMessageView`,
-    v,
-  ) as ValidationResult<DeletedMessageView>
+export function validateDeletedMessageView<V>(v: V) {
+  return validate<DeletedMessageView & V>(v, id, hashDeletedMessageView)
 }
 
-export function isValidDeletedMessageView<V>(
-  v: V,
-): v is V & $Typed<DeletedMessageView> {
-  return isDeletedMessageView(v) && validateDeletedMessageView(v).success
+export function isValidDeletedMessageView<V>(v: V) {
+  return isValid<DeletedMessageView>(v, id, hashDeletedMessageView)
 }
 
 export interface MessageViewSender {
@@ -113,21 +113,18 @@ export interface MessageViewSender {
   did: string
 }
 
+const hashMessageViewSender = 'messageViewSender'
+
 export function isMessageViewSender<V>(v: V) {
-  return is$typed(v, id, 'messageViewSender')
+  return is$typed(v, id, hashMessageViewSender)
 }
 
-export function validateMessageViewSender(v: unknown) {
-  return lexicons.validate(
-    `${id}#messageViewSender`,
-    v,
-  ) as ValidationResult<MessageViewSender>
+export function validateMessageViewSender<V>(v: V) {
+  return validate<MessageViewSender & V>(v, id, hashMessageViewSender)
 }
 
-export function isValidMessageViewSender<V>(
-  v: V,
-): v is V & $Typed<MessageViewSender> {
-  return isMessageViewSender(v) && validateMessageViewSender(v).success
+export function isValidMessageViewSender<V>(v: V) {
+  return isValid<MessageViewSender>(v, id, hashMessageViewSender)
 }
 
 export interface ConvoView {
@@ -144,16 +141,18 @@ export interface ConvoView {
   unreadCount: number
 }
 
+const hashConvoView = 'convoView'
+
 export function isConvoView<V>(v: V) {
-  return is$typed(v, id, 'convoView')
+  return is$typed(v, id, hashConvoView)
 }
 
-export function validateConvoView(v: unknown) {
-  return lexicons.validate(`${id}#convoView`, v) as ValidationResult<ConvoView>
+export function validateConvoView<V>(v: V) {
+  return validate<ConvoView & V>(v, id, hashConvoView)
 }
 
-export function isValidConvoView<V>(v: V): v is V & $Typed<ConvoView> {
-  return isConvoView(v) && validateConvoView(v).success
+export function isValidConvoView<V>(v: V) {
+  return isValid<ConvoView>(v, id, hashConvoView)
 }
 
 export interface LogBeginConvo {
@@ -162,19 +161,18 @@ export interface LogBeginConvo {
   convoId: string
 }
 
+const hashLogBeginConvo = 'logBeginConvo'
+
 export function isLogBeginConvo<V>(v: V) {
-  return is$typed(v, id, 'logBeginConvo')
+  return is$typed(v, id, hashLogBeginConvo)
 }
 
-export function validateLogBeginConvo(v: unknown) {
-  return lexicons.validate(
-    `${id}#logBeginConvo`,
-    v,
-  ) as ValidationResult<LogBeginConvo>
+export function validateLogBeginConvo<V>(v: V) {
+  return validate<LogBeginConvo & V>(v, id, hashLogBeginConvo)
 }
 
-export function isValidLogBeginConvo<V>(v: V): v is V & $Typed<LogBeginConvo> {
-  return isLogBeginConvo(v) && validateLogBeginConvo(v).success
+export function isValidLogBeginConvo<V>(v: V) {
+  return isValid<LogBeginConvo>(v, id, hashLogBeginConvo)
 }
 
 export interface LogLeaveConvo {
@@ -183,19 +181,18 @@ export interface LogLeaveConvo {
   convoId: string
 }
 
+const hashLogLeaveConvo = 'logLeaveConvo'
+
 export function isLogLeaveConvo<V>(v: V) {
-  return is$typed(v, id, 'logLeaveConvo')
+  return is$typed(v, id, hashLogLeaveConvo)
 }
 
-export function validateLogLeaveConvo(v: unknown) {
-  return lexicons.validate(
-    `${id}#logLeaveConvo`,
-    v,
-  ) as ValidationResult<LogLeaveConvo>
+export function validateLogLeaveConvo<V>(v: V) {
+  return validate<LogLeaveConvo & V>(v, id, hashLogLeaveConvo)
 }
 
-export function isValidLogLeaveConvo<V>(v: V): v is V & $Typed<LogLeaveConvo> {
-  return isLogLeaveConvo(v) && validateLogLeaveConvo(v).success
+export function isValidLogLeaveConvo<V>(v: V) {
+  return isValid<LogLeaveConvo>(v, id, hashLogLeaveConvo)
 }
 
 export interface LogCreateMessage {
@@ -205,21 +202,18 @@ export interface LogCreateMessage {
   message: $Typed<MessageView> | $Typed<DeletedMessageView> | { $type: string }
 }
 
+const hashLogCreateMessage = 'logCreateMessage'
+
 export function isLogCreateMessage<V>(v: V) {
-  return is$typed(v, id, 'logCreateMessage')
+  return is$typed(v, id, hashLogCreateMessage)
 }
 
-export function validateLogCreateMessage(v: unknown) {
-  return lexicons.validate(
-    `${id}#logCreateMessage`,
-    v,
-  ) as ValidationResult<LogCreateMessage>
+export function validateLogCreateMessage<V>(v: V) {
+  return validate<LogCreateMessage & V>(v, id, hashLogCreateMessage)
 }
 
-export function isValidLogCreateMessage<V>(
-  v: V,
-): v is V & $Typed<LogCreateMessage> {
-  return isLogCreateMessage(v) && validateLogCreateMessage(v).success
+export function isValidLogCreateMessage<V>(v: V) {
+  return isValid<LogCreateMessage>(v, id, hashLogCreateMessage)
 }
 
 export interface LogDeleteMessage {
@@ -229,19 +223,16 @@ export interface LogDeleteMessage {
   message: $Typed<MessageView> | $Typed<DeletedMessageView> | { $type: string }
 }
 
+const hashLogDeleteMessage = 'logDeleteMessage'
+
 export function isLogDeleteMessage<V>(v: V) {
-  return is$typed(v, id, 'logDeleteMessage')
+  return is$typed(v, id, hashLogDeleteMessage)
 }
 
-export function validateLogDeleteMessage(v: unknown) {
-  return lexicons.validate(
-    `${id}#logDeleteMessage`,
-    v,
-  ) as ValidationResult<LogDeleteMessage>
+export function validateLogDeleteMessage<V>(v: V) {
+  return validate<LogDeleteMessage & V>(v, id, hashLogDeleteMessage)
 }
 
-export function isValidLogDeleteMessage<V>(
-  v: V,
-): v is V & $Typed<LogDeleteMessage> {
-  return isLogDeleteMessage(v) && validateLogDeleteMessage(v).success
+export function isValidLogDeleteMessage<V>(v: V) {
+  return isValid<LogDeleteMessage>(v, id, hashLogDeleteMessage)
 }

package/src/client/types/chat/bsky/convo/deleteMessageForSelf.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.deleteMessageForSelf'
 
 export interface QueryParams {}

package/src/client/types/chat/bsky/convo/getConvo.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.getConvo'
 
 export interface QueryParams {

package/src/client/types/chat/bsky/convo/getConvoForMembers.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.getConvoForMembers'
 
 export interface QueryParams {

package/src/client/types/chat/bsky/convo/getLog.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.getLog'
 
 export interface QueryParams {

package/src/client/types/chat/bsky/convo/getMessages.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.getMessages'
 
 export interface QueryParams {

package/src/client/types/chat/bsky/convo/leaveConvo.ts

@@ -4,9 +4,15 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.leaveConvo'
 
 export interface QueryParams {}

package/src/client/types/chat/bsky/convo/listConvos.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.listConvos'
 
 export interface QueryParams {

package/src/client/types/chat/bsky/convo/muteConvo.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.muteConvo'
 
 export interface QueryParams {}

package/src/client/types/chat/bsky/convo/sendMessage.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.sendMessage'
 
 export interface QueryParams {}

package/src/client/types/chat/bsky/convo/sendMessageBatch.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.sendMessageBatch'
 
 export interface QueryParams {}
@@ -43,14 +49,16 @@ export interface BatchItem {
   message: ChatBskyConvoDefs.MessageInput
 }
 
+const hashBatchItem = 'batchItem'
+
 export function isBatchItem<V>(v: V) {
-  return is$typed(v, id, 'batchItem')
+  return is$typed(v, id, hashBatchItem)
 }
 
-export function validateBatchItem(v: unknown) {
-  return lexicons.validate(`${id}#batchItem`, v) as ValidationResult<BatchItem>
+export function validateBatchItem<V>(v: V) {
+  return validate<BatchItem & V>(v, id, hashBatchItem)
 }
 
-export function isValidBatchItem<V>(v: V): v is V & $Typed<BatchItem> {
-  return isBatchItem(v) && validateBatchItem(v).success
+export function isValidBatchItem<V>(v: V) {
+  return isValid<BatchItem>(v, id, hashBatchItem)
 }

package/src/client/types/chat/bsky/convo/unmuteConvo.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.unmuteConvo'
 
 export interface QueryParams {}

package/src/client/types/chat/bsky/convo/updateRead.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.convo.updateRead'
 
 export interface QueryParams {}

package/src/client/types/chat/bsky/moderation/getActorMetadata.ts

@@ -4,9 +4,15 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.moderation.getActorMetadata'
 
 export interface QueryParams {
@@ -44,14 +50,16 @@ export interface Metadata {
   convosStarted: number
 }
 
+const hashMetadata = 'metadata'
+
 export function isMetadata<V>(v: V) {
-  return is$typed(v, id, 'metadata')
+  return is$typed(v, id, hashMetadata)
 }
 
-export function validateMetadata(v: unknown) {
-  return lexicons.validate(`${id}#metadata`, v) as ValidationResult<Metadata>
+export function validateMetadata<V>(v: V) {
+  return validate<Metadata & V>(v, id, hashMetadata)
 }
 
-export function isValidMetadata<V>(v: V): v is V & $Typed<Metadata> {
-  return isMetadata(v) && validateMetadata(v).success
+export function isValidMetadata<V>(v: V) {
+  return isValid<Metadata>(v, id, hashMetadata)
 }

package/src/client/types/chat/bsky/moderation/getMessageContext.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ChatBskyConvoDefs from '../convo/defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ChatBskyConvoDefs from '../convo/defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.moderation.getMessageContext'
 
 export interface QueryParams {

package/src/client/types/chat/bsky/moderation/updateActorAccess.ts

@@ -4,9 +4,15 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'chat.bsky.moderation.updateActorAccess'
 
 export interface QueryParams {}