@atproto/api 0.19.7 → 0.19.9

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

@@ -12,11 +12,20 @@ import {
 import type * as AppBskyRichtextFacet from '../../../app/bsky/richtext/facet.js'
 import type * as AppBskyEmbedRecord from '../../../app/bsky/embed/record.js'
 import type * as ChatBskyActorDefs from '../actor/defs.js'
+import type * as ChatBskyGroupDefs from '../group/defs.js'
 
 const is$typed = _is$typed,
   validate = _validate
 const id = 'chat.bsky.convo.defs'
 
+export type ConvoKind = 'direct' | 'group' | (string & {})
+export type ConvoLockStatus =
+  | 'unlocked'
+  | 'locked'
+  | 'locked-permanently'
+  | (string & {})
+export type ConvoStatus = 'request' | 'accepted' | (string & {})
+
 export interface MessageRef {
   $type?: 'chat.bsky.convo.defs#messageRef'
   did: string
@@ -76,6 +85,283 @@ export function validateMessageView<V>(v: V) {
   return validate<MessageView & V>(v, id, hashMessageView)
 }
 
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. */
+export interface SystemMessageView {
+  $type?: 'chat.bsky.convo.defs#systemMessageView'
+  id: string
+  rev: string
+  sentAt: string
+  data:
+    | $Typed<SystemMessageDataAddMember>
+    | $Typed<SystemMessageDataRemoveMember>
+    | $Typed<SystemMessageDataMemberJoin>
+    | $Typed<SystemMessageDataMemberLeave>
+    | $Typed<SystemMessageDataLockConvo>
+    | $Typed<SystemMessageDataUnlockConvo>
+    | $Typed<SystemMessageDataLockConvoPermanently>
+    | $Typed<SystemMessageDataEditGroup>
+    | $Typed<SystemMessageDataCreateJoinLink>
+    | $Typed<SystemMessageDataEditJoinLink>
+    | $Typed<SystemMessageDataEnableJoinLink>
+    | $Typed<SystemMessageDataDisableJoinLink>
+    | { $type: string }
+}
+
+const hashSystemMessageView = 'systemMessageView'
+
+export function isSystemMessageView<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageView)
+}
+
+export function validateSystemMessageView<V>(v: V) {
+  return validate<SystemMessageView & V>(v, id, hashSystemMessageView)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user was added to the group convo. */
+export interface SystemMessageDataAddMember {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataAddMember'
+  member: ChatBskyActorDefs.ProfileViewBasic
+  role: ChatBskyActorDefs.MemberRole
+  addedBy: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashSystemMessageDataAddMember = 'systemMessageDataAddMember'
+
+export function isSystemMessageDataAddMember<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataAddMember)
+}
+
+export function validateSystemMessageDataAddMember<V>(v: V) {
+  return validate<SystemMessageDataAddMember & V>(
+    v,
+    id,
+    hashSystemMessageDataAddMember,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user was removed from the group convo. */
+export interface SystemMessageDataRemoveMember {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataRemoveMember'
+  member: ChatBskyActorDefs.ProfileViewBasic
+  removedBy: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashSystemMessageDataRemoveMember = 'systemMessageDataRemoveMember'
+
+export function isSystemMessageDataRemoveMember<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataRemoveMember)
+}
+
+export function validateSystemMessageDataRemoveMember<V>(v: V) {
+  return validate<SystemMessageDataRemoveMember & V>(
+    v,
+    id,
+    hashSystemMessageDataRemoveMember,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user joined the group convo via join link. */
+export interface SystemMessageDataMemberJoin {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataMemberJoin'
+  member: ChatBskyActorDefs.ProfileViewBasic
+  role: ChatBskyActorDefs.MemberRole
+  approvedBy?: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashSystemMessageDataMemberJoin = 'systemMessageDataMemberJoin'
+
+export function isSystemMessageDataMemberJoin<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataMemberJoin)
+}
+
+export function validateSystemMessageDataMemberJoin<V>(v: V) {
+  return validate<SystemMessageDataMemberJoin & V>(
+    v,
+    id,
+    hashSystemMessageDataMemberJoin,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating a user voluntarily left the group convo. */
+export interface SystemMessageDataMemberLeave {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataMemberLeave'
+  member: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashSystemMessageDataMemberLeave = 'systemMessageDataMemberLeave'
+
+export function isSystemMessageDataMemberLeave<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataMemberLeave)
+}
+
+export function validateSystemMessageDataMemberLeave<V>(v: V) {
+  return validate<SystemMessageDataMemberLeave & V>(
+    v,
+    id,
+    hashSystemMessageDataMemberLeave,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group convo was locked. */
+export interface SystemMessageDataLockConvo {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataLockConvo'
+  lockedBy: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashSystemMessageDataLockConvo = 'systemMessageDataLockConvo'
+
+export function isSystemMessageDataLockConvo<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataLockConvo)
+}
+
+export function validateSystemMessageDataLockConvo<V>(v: V) {
+  return validate<SystemMessageDataLockConvo & V>(
+    v,
+    id,
+    hashSystemMessageDataLockConvo,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group convo was unlocked. */
+export interface SystemMessageDataUnlockConvo {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataUnlockConvo'
+  unlockedBy: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashSystemMessageDataUnlockConvo = 'systemMessageDataUnlockConvo'
+
+export function isSystemMessageDataUnlockConvo<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataUnlockConvo)
+}
+
+export function validateSystemMessageDataUnlockConvo<V>(v: V) {
+  return validate<SystemMessageDataUnlockConvo & V>(
+    v,
+    id,
+    hashSystemMessageDataUnlockConvo,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group convo was locked permanently. */
+export interface SystemMessageDataLockConvoPermanently {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataLockConvoPermanently'
+  lockedBy: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashSystemMessageDataLockConvoPermanently =
+  'systemMessageDataLockConvoPermanently'
+
+export function isSystemMessageDataLockConvoPermanently<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataLockConvoPermanently)
+}
+
+export function validateSystemMessageDataLockConvoPermanently<V>(v: V) {
+  return validate<SystemMessageDataLockConvoPermanently & V>(
+    v,
+    id,
+    hashSystemMessageDataLockConvoPermanently,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group info was edited. */
+export interface SystemMessageDataEditGroup {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataEditGroup'
+  /** Group name that was replaced. */
+  oldName?: string
+  /** Group name that replaced the old. */
+  newName?: string
+}
+
+const hashSystemMessageDataEditGroup = 'systemMessageDataEditGroup'
+
+export function isSystemMessageDataEditGroup<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataEditGroup)
+}
+
+export function validateSystemMessageDataEditGroup<V>(v: V) {
+  return validate<SystemMessageDataEditGroup & V>(
+    v,
+    id,
+    hashSystemMessageDataEditGroup,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was created. */
+export interface SystemMessageDataCreateJoinLink {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataCreateJoinLink'
+}
+
+const hashSystemMessageDataCreateJoinLink = 'systemMessageDataCreateJoinLink'
+
+export function isSystemMessageDataCreateJoinLink<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataCreateJoinLink)
+}
+
+export function validateSystemMessageDataCreateJoinLink<V>(v: V) {
+  return validate<SystemMessageDataCreateJoinLink & V>(
+    v,
+    id,
+    hashSystemMessageDataCreateJoinLink,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was edited. */
+export interface SystemMessageDataEditJoinLink {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataEditJoinLink'
+}
+
+const hashSystemMessageDataEditJoinLink = 'systemMessageDataEditJoinLink'
+
+export function isSystemMessageDataEditJoinLink<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataEditJoinLink)
+}
+
+export function validateSystemMessageDataEditJoinLink<V>(v: V) {
+  return validate<SystemMessageDataEditJoinLink & V>(
+    v,
+    id,
+    hashSystemMessageDataEditJoinLink,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was enabled. */
+export interface SystemMessageDataEnableJoinLink {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataEnableJoinLink'
+}
+
+const hashSystemMessageDataEnableJoinLink = 'systemMessageDataEnableJoinLink'
+
+export function isSystemMessageDataEnableJoinLink<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataEnableJoinLink)
+}
+
+export function validateSystemMessageDataEnableJoinLink<V>(v: V) {
+  return validate<SystemMessageDataEnableJoinLink & V>(
+    v,
+    id,
+    hashSystemMessageDataEnableJoinLink,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. System message indicating the group join link was disabled. */
+export interface SystemMessageDataDisableJoinLink {
+  $type?: 'chat.bsky.convo.defs#systemMessageDataDisableJoinLink'
+}
+
+const hashSystemMessageDataDisableJoinLink = 'systemMessageDataDisableJoinLink'
+
+export function isSystemMessageDataDisableJoinLink<V>(v: V) {
+  return is$typed(v, id, hashSystemMessageDataDisableJoinLink)
+}
+
+export function validateSystemMessageDataDisableJoinLink<V>(v: V) {
+  return validate<SystemMessageDataDisableJoinLink & V>(
+    v,
+    id,
+    hashSystemMessageDataDisableJoinLink,
+  )
+}
+
 export interface DeletedMessageView {
   $type?: 'chat.bsky.convo.defs#deletedMessageView'
   id: string
@@ -165,11 +451,13 @@ export interface ConvoView {
   lastMessage?:
     | $Typed<MessageView>
     | $Typed<DeletedMessageView>
+    | $Typed<SystemMessageView>
     | { $type: string }
   lastReaction?: $Typed<MessageAndReactionView> | { $type: string }
   muted: boolean
-  status?: 'request' | 'accepted' | (string & {})
+  status?: ConvoStatus
   unreadCount: number
+  kind?: $Typed<DirectConvo> | $Typed<GroupConvo> | { $type: string }
 }
 
 const hashConvoView = 'convoView'
@@ -182,6 +470,41 @@ export function validateConvoView<V>(v: V) {
   return validate<ConvoView & V>(v, id, hashConvoView)
 }
 
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. */
+export interface DirectConvo {
+  $type?: 'chat.bsky.convo.defs#directConvo'
+}
+
+const hashDirectConvo = 'directConvo'
+
+export function isDirectConvo<V>(v: V) {
+  return is$typed(v, id, hashDirectConvo)
+}
+
+export function validateDirectConvo<V>(v: V) {
+  return validate<DirectConvo & V>(v, id, hashDirectConvo)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. */
+export interface GroupConvo {
+  $type?: 'chat.bsky.convo.defs#groupConvo'
+  /** The display name of the group conversation. */
+  name: string
+  joinLink?: ChatBskyGroupDefs.JoinLinkView
+  lockStatus: ConvoLockStatus
+}
+
+const hashGroupConvo = 'groupConvo'
+
+export function isGroupConvo<V>(v: V) {
+  return is$typed(v, id, hashGroupConvo)
+}
+
+export function validateGroupConvo<V>(v: V) {
+  return validate<GroupConvo & V>(v, id, hashGroupConvo)
+}
+
+/** Event indicating a convo containing the viewer was started. Can be direct or group. When a member is added to a group convo, they also get this event. */
 export interface LogBeginConvo {
   $type?: 'chat.bsky.convo.defs#logBeginConvo'
   rev: string
@@ -198,6 +521,7 @@ export function validateLogBeginConvo<V>(v: V) {
   return validate<LogBeginConvo & V>(v, id, hashLogBeginConvo)
 }
 
+/** Event indicating the viewer accepted a convo, and it can be moved out of the request inbox. Can be direct or group. */
 export interface LogAcceptConvo {
   $type?: 'chat.bsky.convo.defs#logAcceptConvo'
   rev: string
@@ -214,6 +538,7 @@ export function validateLogAcceptConvo<V>(v: V) {
   return validate<LogAcceptConvo & V>(v, id, hashLogAcceptConvo)
 }
 
+/** Event indicating the viewer left a convo. Can be direct or group. */
 export interface LogLeaveConvo {
   $type?: 'chat.bsky.convo.defs#logLeaveConvo'
   rev: string
@@ -230,6 +555,7 @@ export function validateLogLeaveConvo<V>(v: V) {
   return validate<LogLeaveConvo & V>(v, id, hashLogLeaveConvo)
 }
 
+/** Event indicating the viewer muted a convo. Can be direct or group. */
 export interface LogMuteConvo {
   $type?: 'chat.bsky.convo.defs#logMuteConvo'
   rev: string
@@ -246,6 +572,7 @@ export function validateLogMuteConvo<V>(v: V) {
   return validate<LogMuteConvo & V>(v, id, hashLogMuteConvo)
 }
 
+/** Event indicating the viewer unmuted a convo. Can be direct or group. */
 export interface LogUnmuteConvo {
   $type?: 'chat.bsky.convo.defs#logUnmuteConvo'
   rev: string
@@ -262,6 +589,7 @@ export function validateLogUnmuteConvo<V>(v: V) {
   return validate<LogUnmuteConvo & V>(v, id, hashLogUnmuteConvo)
 }
 
+/** Event indicating a user-originated message was created. Is not emitted for system messages. */
 export interface LogCreateMessage {
   $type?: 'chat.bsky.convo.defs#logCreateMessage'
   rev: string
@@ -279,6 +607,7 @@ export function validateLogCreateMessage<V>(v: V) {
   return validate<LogCreateMessage & V>(v, id, hashLogCreateMessage)
 }
 
+/** Event indicating a user-originated message was deleted. Is not emitted for system messages. */
 export interface LogDeleteMessage {
   $type?: 'chat.bsky.convo.defs#logDeleteMessage'
   rev: string
@@ -296,11 +625,16 @@ export function validateLogDeleteMessage<V>(v: V) {
   return validate<LogDeleteMessage & V>(v, id, hashLogDeleteMessage)
 }
 
+/** DEPRECATED: use logReadConvo instead. Event indicating a convo was read up to a certain message. */
 export interface LogReadMessage {
   $type?: 'chat.bsky.convo.defs#logReadMessage'
   rev: string
   convoId: string
-  message: $Typed<MessageView> | $Typed<DeletedMessageView> | { $type: string }
+  message:
+    | $Typed<MessageView>
+    | $Typed<DeletedMessageView>
+    | $Typed<SystemMessageView>
+    | { $type: string }
 }
 
 const hashLogReadMessage = 'logReadMessage'
@@ -313,6 +647,7 @@ export function validateLogReadMessage<V>(v: V) {
   return validate<LogReadMessage & V>(v, id, hashLogReadMessage)
 }
 
+/** Event indicating a reaction was added to a message. */
 export interface LogAddReaction {
   $type?: 'chat.bsky.convo.defs#logAddReaction'
   rev: string
@@ -331,6 +666,7 @@ export function validateLogAddReaction<V>(v: V) {
   return validate<LogAddReaction & V>(v, id, hashLogAddReaction)
 }
 
+/** Event indicating a reaction was removed from a message. */
 export interface LogRemoveReaction {
   $type?: 'chat.bsky.convo.defs#logRemoveReaction'
   rev: string
@@ -348,3 +684,316 @@ export function isLogRemoveReaction<V>(v: V) {
 export function validateLogRemoveReaction<V>(v: V) {
   return validate<LogRemoveReaction & V>(v, id, hashLogRemoveReaction)
 }
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a convo was read up to a certain message. */
+export interface LogReadConvo {
+  $type?: 'chat.bsky.convo.defs#logReadConvo'
+  rev: string
+  convoId: string
+  message:
+    | $Typed<MessageView>
+    | $Typed<DeletedMessageView>
+    | $Typed<SystemMessageView>
+    | { $type: string }
+}
+
+const hashLogReadConvo = 'logReadConvo'
+
+export function isLogReadConvo<V>(v: V) {
+  return is$typed(v, id, hashLogReadConvo)
+}
+
+export function validateLogReadConvo<V>(v: V) {
+  return validate<LogReadConvo & V>(v, id, hashLogReadConvo)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member was added to a group convo. The member who was added gets a logBeginConvo (to create the convo) but also a logAddMember (to show the system message as the first message the user sees). */
+export interface LogAddMember {
+  $type?: 'chat.bsky.convo.defs#logAddMember'
+  rev: string
+  convoId: string
+  message: SystemMessageDataAddMember
+}
+
+const hashLogAddMember = 'logAddMember'
+
+export function isLogAddMember<V>(v: V) {
+  return is$typed(v, id, hashLogAddMember)
+}
+
+export function validateLogAddMember<V>(v: V) {
+  return validate<LogAddMember & V>(v, id, hashLogAddMember)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member was removed from a group convo. The member who was removed gets a logLeaveConvo (to leave the convo) but not a logRemoveMember (because they already left, so can't see the system message). */
+export interface LogRemoveMember {
+  $type?: 'chat.bsky.convo.defs#logRemoveMember'
+  rev: string
+  convoId: string
+  message: SystemMessageDataRemoveMember
+}
+
+const hashLogRemoveMember = 'logRemoveMember'
+
+export function isLogRemoveMember<V>(v: V) {
+  return is$typed(v, id, hashLogRemoveMember)
+}
+
+export function validateLogRemoveMember<V>(v: V) {
+  return validate<LogRemoveMember & V>(v, id, hashLogRemoveMember)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member joined a group convo via join link. The member who was added gets a logBeginConvo (to create the convo) but also a logMemberJoin (to show the system message as the first message the user sees). */
+export interface LogMemberJoin {
+  $type?: 'chat.bsky.convo.defs#logMemberJoin'
+  rev: string
+  convoId: string
+  message: SystemMessageDataMemberJoin
+}
+
+const hashLogMemberJoin = 'logMemberJoin'
+
+export function isLogMemberJoin<V>(v: V) {
+  return is$typed(v, id, hashLogMemberJoin)
+}
+
+export function validateLogMemberJoin<V>(v: V) {
+  return validate<LogMemberJoin & V>(v, id, hashLogMemberJoin)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a member voluntarily left a group convo. The member who was removed gets a logLeaveConvo (to leave the convo) but not a logMemberLeave (because they already left, so can't see the system message). */
+export interface LogMemberLeave {
+  $type?: 'chat.bsky.convo.defs#logMemberLeave'
+  rev: string
+  convoId: string
+  message: SystemMessageDataMemberLeave
+}
+
+const hashLogMemberLeave = 'logMemberLeave'
+
+export function isLogMemberLeave<V>(v: V) {
+  return is$typed(v, id, hashLogMemberLeave)
+}
+
+export function validateLogMemberLeave<V>(v: V) {
+  return validate<LogMemberLeave & V>(v, id, hashLogMemberLeave)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a group convo was locked. */
+export interface LogLockConvo {
+  $type?: 'chat.bsky.convo.defs#logLockConvo'
+  rev: string
+  convoId: string
+  message: SystemMessageDataLockConvo
+}
+
+const hashLogLockConvo = 'logLockConvo'
+
+export function isLogLockConvo<V>(v: V) {
+  return is$typed(v, id, hashLogLockConvo)
+}
+
+export function validateLogLockConvo<V>(v: V) {
+  return validate<LogLockConvo & V>(v, id, hashLogLockConvo)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a group convo was unlocked. */
+export interface LogUnlockConvo {
+  $type?: 'chat.bsky.convo.defs#logUnlockConvo'
+  rev: string
+  convoId: string
+  message: SystemMessageDataUnlockConvo
+}
+
+const hashLogUnlockConvo = 'logUnlockConvo'
+
+export function isLogUnlockConvo<V>(v: V) {
+  return is$typed(v, id, hashLogUnlockConvo)
+}
+
+export function validateLogUnlockConvo<V>(v: V) {
+  return validate<LogUnlockConvo & V>(v, id, hashLogUnlockConvo)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a group convo was locked permanently. */
+export interface LogLockConvoPermanently {
+  $type?: 'chat.bsky.convo.defs#logLockConvoPermanently'
+  rev: string
+  convoId: string
+  message: SystemMessageDataLockConvoPermanently
+}
+
+const hashLogLockConvoPermanently = 'logLockConvoPermanently'
+
+export function isLogLockConvoPermanently<V>(v: V) {
+  return is$typed(v, id, hashLogLockConvoPermanently)
+}
+
+export function validateLogLockConvoPermanently<V>(v: V) {
+  return validate<LogLockConvoPermanently & V>(
+    v,
+    id,
+    hashLogLockConvoPermanently,
+  )
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating info about group convo was edited. */
+export interface LogEditGroup {
+  $type?: 'chat.bsky.convo.defs#logEditGroup'
+  rev: string
+  convoId: string
+  message: SystemMessageDataEditGroup
+}
+
+const hashLogEditGroup = 'logEditGroup'
+
+export function isLogEditGroup<V>(v: V) {
+  return is$typed(v, id, hashLogEditGroup)
+}
+
+export function validateLogEditGroup<V>(v: V) {
+  return validate<LogEditGroup & V>(v, id, hashLogEditGroup)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join link was created for a group convo. */
+export interface LogCreateJoinLink {
+  $type?: 'chat.bsky.convo.defs#logCreateJoinLink'
+  rev: string
+  convoId: string
+  message: SystemMessageDataCreateJoinLink
+}
+
+const hashLogCreateJoinLink = 'logCreateJoinLink'
+
+export function isLogCreateJoinLink<V>(v: V) {
+  return is$typed(v, id, hashLogCreateJoinLink)
+}
+
+export function validateLogCreateJoinLink<V>(v: V) {
+  return validate<LogCreateJoinLink & V>(v, id, hashLogCreateJoinLink)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a settings about a join link for a group convo were edited. */
+export interface LogEditJoinLink {
+  $type?: 'chat.bsky.convo.defs#logEditJoinLink'
+  rev: string
+  convoId: string
+  message: SystemMessageDataEditJoinLink
+}
+
+const hashLogEditJoinLink = 'logEditJoinLink'
+
+export function isLogEditJoinLink<V>(v: V) {
+  return is$typed(v, id, hashLogEditJoinLink)
+}
+
+export function validateLogEditJoinLink<V>(v: V) {
+  return validate<LogEditJoinLink & V>(v, id, hashLogEditJoinLink)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join link was enabled for a group convo. */
+export interface LogEnableJoinLink {
+  $type?: 'chat.bsky.convo.defs#logEnableJoinLink'
+  rev: string
+  convoId: string
+  message: SystemMessageDataEnableJoinLink
+}
+
+const hashLogEnableJoinLink = 'logEnableJoinLink'
+
+export function isLogEnableJoinLink<V>(v: V) {
+  return is$typed(v, id, hashLogEnableJoinLink)
+}
+
+export function validateLogEnableJoinLink<V>(v: V) {
+  return validate<LogEnableJoinLink & V>(v, id, hashLogEnableJoinLink)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join link was disabled for a group convo. */
+export interface LogDisableJoinLink {
+  $type?: 'chat.bsky.convo.defs#logDisableJoinLink'
+  rev: string
+  convoId: string
+  message: SystemMessageDataDisableJoinLink
+}
+
+const hashLogDisableJoinLink = 'logDisableJoinLink'
+
+export function isLogDisableJoinLink<V>(v: V) {
+  return is$typed(v, id, hashLogDisableJoinLink)
+}
+
+export function validateLogDisableJoinLink<V>(v: V) {
+  return validate<LogDisableJoinLink & V>(v, id, hashLogDisableJoinLink)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was made to a group the viewer owns. Only the owner gets this. */
+export interface LogIncomingJoinRequest {
+  $type?: 'chat.bsky.convo.defs#logIncomingJoinRequest'
+  rev: string
+  convoId: string
+  member: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashLogIncomingJoinRequest = 'logIncomingJoinRequest'
+
+export function isLogIncomingJoinRequest<V>(v: V) {
+  return is$typed(v, id, hashLogIncomingJoinRequest)
+}
+
+export function validateLogIncomingJoinRequest<V>(v: V) {
+  return validate<LogIncomingJoinRequest & V>(v, id, hashLogIncomingJoinRequest)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was approved by the viewer. Only the owner gets this. The approved member gets a logBeginConvo. */
+export interface LogApproveJoinRequest {
+  $type?: 'chat.bsky.convo.defs#logApproveJoinRequest'
+  rev: string
+  convoId: string
+  member: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashLogApproveJoinRequest = 'logApproveJoinRequest'
+
+export function isLogApproveJoinRequest<V>(v: V) {
+  return is$typed(v, id, hashLogApproveJoinRequest)
+}
+
+export function validateLogApproveJoinRequest<V>(v: V) {
+  return validate<LogApproveJoinRequest & V>(v, id, hashLogApproveJoinRequest)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was rejected by the viewer. Only the owner gets this. */
+export interface LogRejectJoinRequest {
+  $type?: 'chat.bsky.convo.defs#logRejectJoinRequest'
+  rev: string
+  convoId: string
+  member: ChatBskyActorDefs.ProfileViewBasic
+}
+
+const hashLogRejectJoinRequest = 'logRejectJoinRequest'
+
+export function isLogRejectJoinRequest<V>(v: V) {
+  return is$typed(v, id, hashLogRejectJoinRequest)
+}
+
+export function validateLogRejectJoinRequest<V>(v: V) {
+  return validate<LogRejectJoinRequest & V>(v, id, hashLogRejectJoinRequest)
+}
+
+/** [NOTE: This is under active development and should be considered unstable while this note is here]. Event indicating a join request was made by the viewer. */
+export interface LogOutgoingJoinRequest {
+  $type?: 'chat.bsky.convo.defs#logOutgoingJoinRequest'
+  rev: string
+  convoId: string
+}
+
+const hashLogOutgoingJoinRequest = 'logOutgoingJoinRequest'
+
+export function isLogOutgoingJoinRequest<V>(v: V) {
+  return is$typed(v, id, hashLogOutgoingJoinRequest)
+}
+
+export function validateLogOutgoingJoinRequest<V>(v: V) {
+  return validate<LogOutgoingJoinRequest & V>(v, id, hashLogOutgoingJoinRequest)
+}