@atproto/api 0.13.19 → 0.14.0-next.0

package/src/client/types/app/bsky/video/getUploadLimits.ts

@@ -3,9 +3,11 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'app.bsky.video.getUploadLimits'
 
 export interface QueryParams {}
 
@@ -17,7 +19,6 @@ export interface OutputSchema {
   remainingDailyBytes?: number
   message?: string
   error?: string
-  [k: string]: unknown
 }
 
 export interface CallOptions {

package/src/client/types/app/bsky/video/uploadVideo.ts

@@ -3,18 +3,19 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as AppBskyVideoDefs from './defs'
 
+const id = 'app.bsky.video.uploadVideo'
+
 export interface QueryParams {}
 
 export type InputSchema = string | Uint8Array | Blob
 
 export interface OutputSchema {
   jobStatus: AppBskyVideoDefs.JobStatus
-  [k: string]: unknown
 }
 
 export interface CallOptions {

package/src/client/types/chat/bsky/actor/declaration.ts

@@ -2,24 +2,26 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'chat.bsky.actor.declaration'
 
 export interface Record {
+  $type?: $Type<'chat.bsky.actor.declaration', 'main'>
   allowIncoming: 'all' | 'none' | 'following' | (string & {})
   [k: string]: unknown
 }
 
-export function isRecord(v: unknown): v is Record {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'chat.bsky.actor.declaration#main' ||
-      v.$type === 'chat.bsky.actor.declaration')
-  )
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, 'main')
+}
+
+export function validateRecord(v: unknown) {
+  return lexicons.validate(`${id}#main`, v) as ValidationResult<Record>
 }
 
-export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.actor.declaration#main', v)
+export function isValidRecord<V>(v: V): v is V & $Typed<Record> {
+  return isRecord(v) && validateRecord(v).success
 }

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

@@ -2,13 +2,16 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as AppBskyActorDefs from '../../../app/bsky/actor/defs'
 import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
 
+const id = 'chat.bsky.actor.defs'
+
 export interface ProfileViewBasic {
+  $type?: $Type<'chat.bsky.actor.defs', 'profileViewBasic'>
   did: string
   handle: string
   displayName?: string
@@ -18,17 +21,21 @@ export interface ProfileViewBasic {
   labels?: ComAtprotoLabelDefs.Label[]
   /** Set to true when the actor cannot actively participate in converations */
   chatDisabled?: boolean
-  [k: string]: unknown
 }
 
-export function isProfileViewBasic(v: unknown): v is ProfileViewBasic {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.actor.defs#profileViewBasic'
-  )
+export function isProfileViewBasic<V>(v: V) {
+  return is$typed(v, id, 'profileViewBasic')
+}
+
+export function validateProfileViewBasic(v: unknown) {
+  return lexicons.validate(
+    `${id}#profileViewBasic`,
+    v,
+  ) as ValidationResult<ProfileViewBasic>
 }
 
-export function validateProfileViewBasic(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.actor.defs#profileViewBasic', v)
+export function isValidProfileViewBasic<V>(
+  v: V,
+): v is V & $Typed<ProfileViewBasic> {
+  return isProfileViewBasic(v) && validateProfileViewBasic(v).success
 }

package/src/client/types/chat/bsky/actor/deleteAccount.ts

@@ -3,17 +3,17 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'chat.bsky.actor.deleteAccount'
 
 export interface QueryParams {}
 
 export type InputSchema = undefined
 
-export interface OutputSchema {
-  [k: string]: unknown
-}
+export interface OutputSchema {}
 
 export interface CallOptions {
   signal?: AbortSignal

package/src/client/types/chat/bsky/actor/exportAccountData.ts

@@ -3,9 +3,11 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
+
+const id = 'chat.bsky.actor.exportAccountData'
 
 export interface QueryParams {}
 

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

@@ -2,215 +2,246 @@
  * GENERATED CODE - DO NOT MODIFY
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as AppBskyRichtextFacet from '../../../app/bsky/richtext/facet'
 import * as AppBskyEmbedRecord from '../../../app/bsky/embed/record'
 import * as ChatBskyActorDefs from '../actor/defs'
 
+const id = 'chat.bsky.convo.defs'
+
 export interface MessageRef {
+  $type?: $Type<'chat.bsky.convo.defs', 'messageRef'>
   did: string
   convoId: string
   messageId: string
-  [k: string]: unknown
 }
 
-export function isMessageRef(v: unknown): v is MessageRef {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#messageRef'
-  )
+export function isMessageRef<V>(v: V) {
+  return is$typed(v, id, 'messageRef')
 }
 
-export function validateMessageRef(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#messageRef', v)
+export function validateMessageRef(v: unknown) {
+  return lexicons.validate(
+    `${id}#messageRef`,
+    v,
+  ) as ValidationResult<MessageRef>
+}
+
+export function isValidMessageRef<V>(v: V): v is V & $Typed<MessageRef> {
+  return isMessageRef(v) && validateMessageRef(v).success
 }
 
 export interface MessageInput {
+  $type?: $Type<'chat.bsky.convo.defs', 'messageInput'>
   text: string
   /** Annotations of text (mentions, URLs, hashtags, etc) */
   facets?: AppBskyRichtextFacet.Main[]
-  embed?: AppBskyEmbedRecord.Main | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+  embed?: $Typed<AppBskyEmbedRecord.Main> | { $type: string }
+}
+
+export function isMessageInput<V>(v: V) {
+  return is$typed(v, id, 'messageInput')
 }
 
-export function isMessageInput(v: unknown): v is MessageInput {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#messageInput'
-  )
+export function validateMessageInput(v: unknown) {
+  return lexicons.validate(
+    `${id}#messageInput`,
+    v,
+  ) as ValidationResult<MessageInput>
 }
 
-export function validateMessageInput(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#messageInput', v)
+export function isValidMessageInput<V>(v: V): v is V & $Typed<MessageInput> {
+  return isMessageInput(v) && validateMessageInput(v).success
 }
 
 export interface MessageView {
+  $type?: $Type<'chat.bsky.convo.defs', 'messageView'>
   id: string
   rev: string
   text: string
   /** Annotations of text (mentions, URLs, hashtags, etc) */
   facets?: AppBskyRichtextFacet.Main[]
-  embed?: AppBskyEmbedRecord.View | { $type: string; [k: string]: unknown }
+  embed?: $Typed<AppBskyEmbedRecord.View> | { $type: string }
   sender: MessageViewSender
   sentAt: string
-  [k: string]: unknown
 }
 
-export function isMessageView(v: unknown): v is MessageView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#messageView'
-  )
+export function isMessageView<V>(v: V) {
+  return is$typed(v, id, 'messageView')
+}
+
+export function validateMessageView(v: unknown) {
+  return lexicons.validate(
+    `${id}#messageView`,
+    v,
+  ) as ValidationResult<MessageView>
 }
 
-export function validateMessageView(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#messageView', v)
+export function isValidMessageView<V>(v: V): v is V & $Typed<MessageView> {
+  return isMessageView(v) && validateMessageView(v).success
 }
 
 export interface DeletedMessageView {
+  $type?: $Type<'chat.bsky.convo.defs', 'deletedMessageView'>
   id: string
   rev: string
   sender: MessageViewSender
   sentAt: string
-  [k: string]: unknown
 }
 
-export function isDeletedMessageView(v: unknown): v is DeletedMessageView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#deletedMessageView'
-  )
+export function isDeletedMessageView<V>(v: V) {
+  return is$typed(v, id, 'deletedMessageView')
 }
 
-export function validateDeletedMessageView(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#deletedMessageView', v)
+export function validateDeletedMessageView(v: unknown) {
+  return lexicons.validate(
+    `${id}#deletedMessageView`,
+    v,
+  ) as ValidationResult<DeletedMessageView>
+}
+
+export function isValidDeletedMessageView<V>(
+  v: V,
+): v is V & $Typed<DeletedMessageView> {
+  return isDeletedMessageView(v) && validateDeletedMessageView(v).success
 }
 
 export interface MessageViewSender {
+  $type?: $Type<'chat.bsky.convo.defs', 'messageViewSender'>
   did: string
-  [k: string]: unknown
 }
 
-export function isMessageViewSender(v: unknown): v is MessageViewSender {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#messageViewSender'
-  )
+export function isMessageViewSender<V>(v: V) {
+  return is$typed(v, id, 'messageViewSender')
 }
 
-export function validateMessageViewSender(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#messageViewSender', v)
+export function validateMessageViewSender(v: unknown) {
+  return lexicons.validate(
+    `${id}#messageViewSender`,
+    v,
+  ) as ValidationResult<MessageViewSender>
+}
+
+export function isValidMessageViewSender<V>(
+  v: V,
+): v is V & $Typed<MessageViewSender> {
+  return isMessageViewSender(v) && validateMessageViewSender(v).success
 }
 
 export interface ConvoView {
+  $type?: $Type<'chat.bsky.convo.defs', 'convoView'>
   id: string
   rev: string
   members: ChatBskyActorDefs.ProfileViewBasic[]
   lastMessage?:
-    | MessageView
-    | DeletedMessageView
-    | { $type: string; [k: string]: unknown }
+    | $Typed<MessageView>
+    | $Typed<DeletedMessageView>
+    | { $type: string }
   muted: boolean
   opened?: boolean
   unreadCount: number
-  [k: string]: unknown
 }
 
-export function isConvoView(v: unknown): v is ConvoView {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#convoView'
-  )
+export function isConvoView<V>(v: V) {
+  return is$typed(v, id, 'convoView')
+}
+
+export function validateConvoView(v: unknown) {
+  return lexicons.validate(`${id}#convoView`, v) as ValidationResult<ConvoView>
 }
 
-export function validateConvoView(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#convoView', v)
+export function isValidConvoView<V>(v: V): v is V & $Typed<ConvoView> {
+  return isConvoView(v) && validateConvoView(v).success
 }
 
 export interface LogBeginConvo {
+  $type?: $Type<'chat.bsky.convo.defs', 'logBeginConvo'>
   rev: string
   convoId: string
-  [k: string]: unknown
 }
 
-export function isLogBeginConvo(v: unknown): v is LogBeginConvo {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#logBeginConvo'
-  )
+export function isLogBeginConvo<V>(v: V) {
+  return is$typed(v, id, 'logBeginConvo')
 }
 
-export function validateLogBeginConvo(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#logBeginConvo', v)
+export function validateLogBeginConvo(v: unknown) {
+  return lexicons.validate(
+    `${id}#logBeginConvo`,
+    v,
+  ) as ValidationResult<LogBeginConvo>
+}
+
+export function isValidLogBeginConvo<V>(v: V): v is V & $Typed<LogBeginConvo> {
+  return isLogBeginConvo(v) && validateLogBeginConvo(v).success
 }
 
 export interface LogLeaveConvo {
+  $type?: $Type<'chat.bsky.convo.defs', 'logLeaveConvo'>
   rev: string
   convoId: string
-  [k: string]: unknown
 }
 
-export function isLogLeaveConvo(v: unknown): v is LogLeaveConvo {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#logLeaveConvo'
-  )
+export function isLogLeaveConvo<V>(v: V) {
+  return is$typed(v, id, 'logLeaveConvo')
 }
 
-export function validateLogLeaveConvo(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#logLeaveConvo', v)
+export function validateLogLeaveConvo(v: unknown) {
+  return lexicons.validate(
+    `${id}#logLeaveConvo`,
+    v,
+  ) as ValidationResult<LogLeaveConvo>
+}
+
+export function isValidLogLeaveConvo<V>(v: V): v is V & $Typed<LogLeaveConvo> {
+  return isLogLeaveConvo(v) && validateLogLeaveConvo(v).success
 }
 
 export interface LogCreateMessage {
+  $type?: $Type<'chat.bsky.convo.defs', 'logCreateMessage'>
   rev: string
   convoId: string
-  message:
-    | MessageView
-    | DeletedMessageView
-    | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+  message: $Typed<MessageView> | $Typed<DeletedMessageView> | { $type: string }
+}
+
+export function isLogCreateMessage<V>(v: V) {
+  return is$typed(v, id, 'logCreateMessage')
 }
 
-export function isLogCreateMessage(v: unknown): v is LogCreateMessage {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#logCreateMessage'
-  )
+export function validateLogCreateMessage(v: unknown) {
+  return lexicons.validate(
+    `${id}#logCreateMessage`,
+    v,
+  ) as ValidationResult<LogCreateMessage>
 }
 
-export function validateLogCreateMessage(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#logCreateMessage', v)
+export function isValidLogCreateMessage<V>(
+  v: V,
+): v is V & $Typed<LogCreateMessage> {
+  return isLogCreateMessage(v) && validateLogCreateMessage(v).success
 }
 
 export interface LogDeleteMessage {
+  $type?: $Type<'chat.bsky.convo.defs', 'logDeleteMessage'>
   rev: string
   convoId: string
-  message:
-    | MessageView
-    | DeletedMessageView
-    | { $type: string; [k: string]: unknown }
-  [k: string]: unknown
+  message: $Typed<MessageView> | $Typed<DeletedMessageView> | { $type: string }
+}
+
+export function isLogDeleteMessage<V>(v: V) {
+  return is$typed(v, id, 'logDeleteMessage')
 }
 
-export function isLogDeleteMessage(v: unknown): v is LogDeleteMessage {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    v.$type === 'chat.bsky.convo.defs#logDeleteMessage'
-  )
+export function validateLogDeleteMessage(v: unknown) {
+  return lexicons.validate(
+    `${id}#logDeleteMessage`,
+    v,
+  ) as ValidationResult<LogDeleteMessage>
 }
 
-export function validateLogDeleteMessage(v: unknown): ValidationResult {
-  return lexicons.validate('chat.bsky.convo.defs#logDeleteMessage', v)
+export function isValidLogDeleteMessage<V>(
+  v: V,
+): v is V & $Typed<LogDeleteMessage> {
+  return isLogDeleteMessage(v) && validateLogDeleteMessage(v).success
 }

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

@@ -3,17 +3,18 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ChatBskyConvoDefs from './defs'
 
+const id = 'chat.bsky.convo.deleteMessageForSelf'
+
 export interface QueryParams {}
 
 export interface InputSchema {
   convoId: string
   messageId: string
-  [k: string]: unknown
 }
 
 export type OutputSchema = ChatBskyConvoDefs.DeletedMessageView

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

@@ -3,11 +3,13 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ChatBskyConvoDefs from './defs'
 
+const id = 'chat.bsky.convo.getConvo'
+
 export interface QueryParams {
   convoId: string
 }
@@ -16,7 +18,6 @@ export type InputSchema = undefined
 
 export interface OutputSchema {
   convo: ChatBskyConvoDefs.ConvoView
-  [k: string]: unknown
 }
 
 export interface CallOptions {

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

@@ -3,11 +3,13 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ChatBskyConvoDefs from './defs'
 
+const id = 'chat.bsky.convo.getConvoForMembers'
+
 export interface QueryParams {
   members: string[]
 }
@@ -16,7 +18,6 @@ export type InputSchema = undefined
 
 export interface OutputSchema {
   convo: ChatBskyConvoDefs.ConvoView
-  [k: string]: unknown
 }
 
 export interface CallOptions {

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

@@ -3,11 +3,13 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ChatBskyConvoDefs from './defs'
 
+const id = 'chat.bsky.convo.getLog'
+
 export interface QueryParams {
   cursor?: string
 }
@@ -17,13 +19,12 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   logs: (
-    | ChatBskyConvoDefs.LogBeginConvo
-    | ChatBskyConvoDefs.LogLeaveConvo
-    | ChatBskyConvoDefs.LogCreateMessage
-    | ChatBskyConvoDefs.LogDeleteMessage
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ChatBskyConvoDefs.LogBeginConvo>
+    | $Typed<ChatBskyConvoDefs.LogLeaveConvo>
+    | $Typed<ChatBskyConvoDefs.LogCreateMessage>
+    | $Typed<ChatBskyConvoDefs.LogDeleteMessage>
+    | { $type: string }
   )[]
-  [k: string]: unknown
 }
 
 export interface CallOptions {

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

@@ -3,11 +3,13 @@
  */
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { isObj, hasProp } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
 import { CID } from 'multiformats/cid'
+import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
+import { lexicons } from '../../../../lexicons'
 import * as ChatBskyConvoDefs from './defs'
 
+const id = 'chat.bsky.convo.getMessages'
+
 export interface QueryParams {
   convoId: string
   limit?: number
@@ -19,11 +21,10 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   messages: (
-    | ChatBskyConvoDefs.MessageView
-    | ChatBskyConvoDefs.DeletedMessageView
-    | { $type: string; [k: string]: unknown }
+    | $Typed<ChatBskyConvoDefs.MessageView>
+    | $Typed<ChatBskyConvoDefs.DeletedMessageView>
+    | { $type: string }
   )[]
-  [k: string]: unknown
 }
 
 export interface CallOptions {