@atproto/pds 0.4.20 → 0.4.22

package/src/lexicon/types/app/bsky/actor/defs.ts

@@ -89,6 +89,7 @@ export interface ProfileAssociated {
   lists?: number
   feedgens?: number
   labeler?: boolean
+  chat?: ProfileAssociatedChat
   [k: string]: unknown
 }
 
@@ -104,6 +105,25 @@ export function validateProfileAssociated(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#profileAssociated', v)
 }
 
+export interface ProfileAssociatedChat {
+  allowIncoming: 'all' | 'none' | 'following' | (string & {})
+  [k: string]: unknown
+}
+
+export function isProfileAssociatedChat(
+  v: unknown,
+): v is ProfileAssociatedChat {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#profileAssociatedChat'
+  )
+}
+
+export function validateProfileAssociatedChat(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#profileAssociatedChat', v)
+}
+
 /** Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests. */
 export interface ViewerState {
   muted?: boolean

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

@@ -0,0 +1,25 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+
+export interface Record {
+  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 validateRecord(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.actor.declaration#main', v)
+}

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

@@ -0,0 +1,34 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as AppBskyActorDefs from '../../../app/bsky/actor/defs'
+import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
+
+export interface ProfileViewBasic {
+  did: string
+  handle: string
+  displayName?: string
+  avatar?: string
+  associated?: AppBskyActorDefs.ProfileAssociated
+  viewer?: AppBskyActorDefs.ViewerState
+  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 validateProfileViewBasic(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.actor.defs#profileViewBasic', v)
+}

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

@@ -0,0 +1,42 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,38 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import stream from 'stream'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/jsonl'
+  body: Uint8Array | stream.Readable
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,215 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as AppBskyRichtextFacet from '../../../app/bsky/richtext/facet'
+import * as AppBskyEmbedRecord from '../../../app/bsky/embed/record'
+import * as ChatBskyActorDefs from '../actor/defs'
+
+export interface MessageRef {
+  did: 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 validateMessageRef(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#messageRef', v)
+}
+
+export interface Message {
+  id?: string
+  text: string
+  /** Annotations of text (mentions, URLs, hashtags, etc) */
+  facets?: AppBskyRichtextFacet.Main[]
+  embed?: AppBskyEmbedRecord.Main | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+export function isMessage(v: unknown): v is Message {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'chat.bsky.convo.defs#message'
+  )
+}
+
+export function validateMessage(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#message', v)
+}
+
+export interface MessageView {
+  id: string
+  rev: string
+  text: string
+  /** Annotations of text (mentions, URLs, hashtags, etc) */
+  facets?: AppBskyRichtextFacet.Main[]
+  embed?: AppBskyEmbedRecord.Main | { $type: string; [k: string]: unknown }
+  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 validateMessageView(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#messageView', v)
+}
+
+export interface 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 validateDeletedMessageView(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#deletedMessageView', v)
+}
+
+export interface 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 validateMessageViewSender(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#messageViewSender', v)
+}
+
+export interface ConvoView {
+  id: string
+  rev: string
+  members: ChatBskyActorDefs.ProfileViewBasic[]
+  lastMessage?:
+    | MessageView
+    | DeletedMessageView
+    | { $type: string; [k: string]: unknown }
+  muted: 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 validateConvoView(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#convoView', v)
+}
+
+export interface 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 validateLogBeginConvo(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#logBeginConvo', v)
+}
+
+export interface 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 validateLogLeaveConvo(v: unknown): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#logLeaveConvo', v)
+}
+
+export interface LogCreateMessage {
+  rev: string
+  convoId: string
+  message:
+    | MessageView
+    | DeletedMessageView
+    | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+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): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#logCreateMessage', v)
+}
+
+export interface LogDeleteMessage {
+  rev: string
+  convoId: string
+  message:
+    | MessageView
+    | DeletedMessageView
+    | { $type: string; [k: string]: unknown }
+  [k: string]: unknown
+}
+
+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): ValidationResult {
+  return lexicons.validate('chat.bsky.convo.defs#logDeleteMessage', v)
+}

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

@@ -0,0 +1,48 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ChatBskyConvoDefs from './defs'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  convoId: string
+  messageId: string
+  [k: string]: unknown
+}
+
+export type OutputSchema = ChatBskyConvoDefs.DeletedMessageView
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,46 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ChatBskyConvoDefs from './defs'
+
+export interface QueryParams {
+  convoId: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  convo: ChatBskyConvoDefs.ConvoView
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,46 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ChatBskyConvoDefs from './defs'
+
+export interface QueryParams {
+  members: string[]
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  convo: ChatBskyConvoDefs.ConvoView
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,53 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ChatBskyConvoDefs from './defs'
+
+export interface QueryParams {
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  logs: (
+    | ChatBskyConvoDefs.LogBeginConvo
+    | ChatBskyConvoDefs.LogLeaveConvo
+    | ChatBskyConvoDefs.LogCreateMessage
+    | ChatBskyConvoDefs.LogDeleteMessage
+    | { $type: string; [k: string]: unknown }
+  )[]
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,53 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ChatBskyConvoDefs from './defs'
+
+export interface QueryParams {
+  convoId: string
+  limit: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  messages: (
+    | ChatBskyConvoDefs.MessageView
+    | ChatBskyConvoDefs.DeletedMessageView
+    | { $type: string; [k: string]: unknown }
+  )[]
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

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

@@ -0,0 +1,50 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  convoId: string
+  [k: string]: unknown
+}
+
+export interface OutputSchema {
+  convoId: string
+  rev: string
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput