@atproto/api 0.19.8 → 0.19.10

package/src/client/types/chat/bsky/group/approveJoinRequest.ts

@@ -0,0 +1,69 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyConvoDefs from '../convo/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.approveJoinRequest'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  convoId: string
+  member: string
+}
+
+export interface OutputSchema {
+  convo: ChatBskyConvoDefs.ConvoView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class InvalidConvoError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InsufficientRoleError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class MemberLimitReachedError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'InvalidConvo') return new InvalidConvoError(e)
+    if (e.error === 'InsufficientRole') return new InsufficientRoleError(e)
+    if (e.error === 'MemberLimitReached') return new MemberLimitReachedError(e)
+  }
+
+  return e
+}

package/src/client/types/chat/bsky/group/createGroup.ts

@@ -0,0 +1,85 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyConvoDefs from '../convo/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.createGroup'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  members: string[]
+  name: string
+}
+
+export interface OutputSchema {
+  convo: ChatBskyConvoDefs.ConvoView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class AccountSuspendedError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class BlockedActorError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class GroupInvitesDisabledError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class NotFollowedBySenderError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class RecipientNotFoundError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'AccountSuspended') return new AccountSuspendedError(e)
+    if (e.error === 'BlockedActor') return new BlockedActorError(e)
+    if (e.error === 'GroupInvitesDisabled')
+      return new GroupInvitesDisabledError(e)
+    if (e.error === 'NotFollowedBySender')
+      return new NotFollowedBySenderError(e)
+    if (e.error === 'RecipientNotFound') return new RecipientNotFoundError(e)
+  }
+
+  return e
+}

package/src/client/types/chat/bsky/group/createJoinLink.ts

@@ -0,0 +1,71 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyGroupDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.createJoinLink'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  convoId: string
+  requireApproval?: boolean
+  joinRule: ChatBskyGroupDefs.JoinRule
+}
+
+export interface OutputSchema {
+  joinLink: ChatBskyGroupDefs.JoinLinkView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class EnabledJoinLinkAlreadyExistsError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidConvoError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InsufficientRoleError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'EnabledJoinLinkAlreadyExists')
+      return new EnabledJoinLinkAlreadyExistsError(e)
+    if (e.error === 'InvalidConvo') return new InvalidConvoError(e)
+    if (e.error === 'InsufficientRole') return new InsufficientRoleError(e)
+  }
+
+  return e
+}

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

@@ -0,0 +1,73 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyActorDefs from '../actor/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.defs'
+
+export type LinkEnabledStatus = 'enabled' | 'disabled' | (string & {})
+export type JoinRule = 'anyone' | 'followedByOwner' | (string & {})
+
+export interface JoinLinkView {
+  $type?: 'chat.bsky.group.defs#joinLinkView'
+  code: string
+  enabledStatus: LinkEnabledStatus
+  requireApproval: boolean
+  joinRule: JoinRule
+  createdAt: string
+}
+
+const hashJoinLinkView = 'joinLinkView'
+
+export function isJoinLinkView<V>(v: V) {
+  return is$typed(v, id, hashJoinLinkView)
+}
+
+export function validateJoinLinkView<V>(v: V) {
+  return validate<JoinLinkView & V>(v, id, hashJoinLinkView)
+}
+
+export interface GroupPublicView {
+  $type?: 'chat.bsky.group.defs#groupPublicView'
+  name: string
+  owner: ChatBskyActorDefs.ProfileViewBasic
+  memberCount: number
+  requireApproval: boolean
+}
+
+const hashGroupPublicView = 'groupPublicView'
+
+export function isGroupPublicView<V>(v: V) {
+  return is$typed(v, id, hashGroupPublicView)
+}
+
+export function validateGroupPublicView<V>(v: V) {
+  return validate<GroupPublicView & V>(v, id, hashGroupPublicView)
+}
+
+export interface JoinRequestView {
+  $type?: 'chat.bsky.group.defs#joinRequestView'
+  convoId: string
+  requestedBy: ChatBskyActorDefs.ProfileViewBasic
+  requestedAt: string
+}
+
+const hashJoinRequestView = 'joinRequestView'
+
+export function isJoinRequestView<V>(v: V) {
+  return is$typed(v, id, hashJoinRequestView)
+}
+
+export function validateJoinRequestView<V>(v: V) {
+  return validate<JoinRequestView & V>(v, id, hashJoinRequestView)
+}

package/src/client/types/chat/bsky/group/disableJoinLink.ts

@@ -0,0 +1,68 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyGroupDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.disableJoinLink'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  convoId: string
+}
+
+export interface OutputSchema {
+  joinLink: ChatBskyGroupDefs.JoinLinkView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class InvalidConvoError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InsufficientRoleError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class NoJoinLinkError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'InvalidConvo') return new InvalidConvoError(e)
+    if (e.error === 'InsufficientRole') return new InsufficientRoleError(e)
+    if (e.error === 'NoJoinLink') return new NoJoinLinkError(e)
+  }
+
+  return e
+}

package/src/client/types/chat/bsky/group/editGroup.ts

@@ -0,0 +1,69 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyConvoDefs from '../convo/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.editGroup'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  convoId: string
+  name: string
+}
+
+export interface OutputSchema {
+  convo: ChatBskyConvoDefs.ConvoView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class ConvoLockedError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InvalidConvoError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InsufficientRoleError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'ConvoLocked') return new ConvoLockedError(e)
+    if (e.error === 'InvalidConvo') return new InvalidConvoError(e)
+    if (e.error === 'InsufficientRole') return new InsufficientRoleError(e)
+  }
+
+  return e
+}

package/src/client/types/chat/bsky/group/editJoinLink.ts

@@ -0,0 +1,70 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyGroupDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.editJoinLink'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  convoId: string
+  requireApproval?: boolean
+  joinRule?: ChatBskyGroupDefs.JoinRule
+}
+
+export interface OutputSchema {
+  joinLink: ChatBskyGroupDefs.JoinLinkView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class InvalidConvoError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InsufficientRoleError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class NoJoinLinkError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'InvalidConvo') return new InvalidConvoError(e)
+    if (e.error === 'InsufficientRole') return new InsufficientRoleError(e)
+    if (e.error === 'NoJoinLink') return new NoJoinLinkError(e)
+  }
+
+  return e
+}

package/src/client/types/chat/bsky/group/enableJoinLink.ts

@@ -0,0 +1,75 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyGroupDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.enableJoinLink'
+
+export type QueryParams = {}
+
+export interface InputSchema {
+  convoId: string
+}
+
+export interface OutputSchema {
+  joinLink: ChatBskyGroupDefs.JoinLinkView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class InvalidConvoError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InsufficientRoleError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class NoJoinLinkError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class LinkAlreadyEnabledError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'InvalidConvo') return new InvalidConvoError(e)
+    if (e.error === 'InsufficientRole') return new InsufficientRoleError(e)
+    if (e.error === 'NoJoinLink') return new NoJoinLinkError(e)
+    if (e.error === 'LinkAlreadyEnabled') return new LinkAlreadyEnabledError(e)
+  }
+
+  return e
+}

package/src/client/types/chat/bsky/group/getGroupPublicInfo.ts

@@ -0,0 +1,51 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyGroupDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.getGroupPublicInfo'
+
+export type QueryParams = {
+  code: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  group: ChatBskyGroupDefs.GroupPublicView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class InvalidCodeError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'InvalidCode') return new InvalidCodeError(e)
+  }
+
+  return e
+}

package/src/client/types/chat/bsky/group/listJoinRequests.ts

@@ -0,0 +1,61 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as ChatBskyGroupDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'chat.bsky.group.listJoinRequests'
+
+export type QueryParams = {
+  convoId: string
+  limit?: number
+  cursor?: string
+}
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  requests: ChatBskyGroupDefs.JoinRequestView[]
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export class InvalidConvoError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export class InsufficientRoleError extends XRPCError {
+  constructor(src: XRPCError) {
+    super(src.status, src.error, src.message, src.headers, { cause: src })
+  }
+}
+
+export function toKnownErr(e: any) {
+  if (e instanceof XRPCError) {
+    if (e.error === 'InvalidConvo') return new InvalidConvoError(e)
+    if (e.error === 'InsufficientRole') return new InsufficientRoleError(e)
+  }
+
+  return e
+}