@atproto/bsky 0.0.30 → 0.0.32

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

@@ -254,3 +254,62 @@ export function isInterestsPref(v: unknown): v is InterestsPref {
 export function validateInterestsPref(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#interestsPref', v)
 }
+
+export type MutedWordTarget = 'content' | 'tag' | (string & {})
+
+/** A word that the account owner has muted. */
+export interface MutedWord {
+  /** The muted word itself. */
+  value: string
+  /** The intended targets of the muted word. */
+  targets: MutedWordTarget[]
+  [k: string]: unknown
+}
+
+export function isMutedWord(v: unknown): v is MutedWord {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#mutedWord'
+  )
+}
+
+export function validateMutedWord(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#mutedWord', v)
+}
+
+export interface MutedWordsPref {
+  /** A list of words the account owner has muted. */
+  items: MutedWord[]
+  [k: string]: unknown
+}
+
+export function isMutedWordsPref(v: unknown): v is MutedWordsPref {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#mutedWordsPref'
+  )
+}
+
+export function validateMutedWordsPref(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#mutedWordsPref', v)
+}
+
+export interface HiddenPostsPref {
+  /** A list of URIs of posts the account owner has hidden. */
+  items: string[]
+  [k: string]: unknown
+}
+
+export function isHiddenPostsPref(v: unknown): v is HiddenPostsPref {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#hiddenPostsPref'
+  )
+}
+
+export function validateHiddenPostsPref(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#hiddenPostsPref', v)
+}

package/src/lexicon/types/app/bsky/feed/post.ts

@@ -32,7 +32,7 @@ export interface Record {
   labels?:
     | ComAtprotoLabelDefs.SelfLabels
     | { $type: string; [k: string]: unknown }
-  /** Additional non-inline tags describing this post. */
+  /** Additional hashtags, in addition to any included in post text and facets. */
   tags?: string[]
   /** Client-declared timestamp when this post was originally created. */
   createdAt: string

package/src/lexicon/types/com/atproto/admin/defs.ts

@@ -156,6 +156,7 @@ export interface SubjectStatusView {
   /** True indicates that the a previously taken moderator action was appealed against, by the author of the content. False indicates last appeal was resolved by moderators. */
   appealed?: boolean
   suspendUntil?: string
+  tags?: string[]
   [k: string]: unknown
 }
 
@@ -720,6 +721,29 @@ export function validateModEventEmail(v: unknown): ValidationResult {
   return lexicons.validate('com.atproto.admin.defs#modEventEmail', v)
 }
 
+/** Add/Remove a tag on a subject */
+export interface ModEventTag {
+  /** Tags to be added to the subject. If already exists, won't be duplicated. */
+  add: string[]
+  /** Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated. */
+  remove: string[]
+  /** Additional comment about added/removed tags. */
+  comment?: string
+  [k: string]: unknown
+}
+
+export function isModEventTag(v: unknown): v is ModEventTag {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'com.atproto.admin.defs#modEventTag'
+  )
+}
+
+export function validateModEventTag(v: unknown): ValidationResult {
+  return lexicons.validate('com.atproto.admin.defs#modEventTag', v)
+}
+
 export interface CommunicationTemplateView {
   id: string
   /** Name of the template. */

package/src/lexicon/types/com/atproto/admin/emitModerationEvent.ts

@@ -24,6 +24,7 @@ export interface InputSchema {
     | ComAtprotoAdminDefs.ModEventReverseTakedown
     | ComAtprotoAdminDefs.ModEventUnmute
     | ComAtprotoAdminDefs.ModEventEmail
+    | ComAtprotoAdminDefs.ModEventTag
     | { $type: string; [k: string]: unknown }
   subject:
     | ComAtprotoAdminDefs.RepoRef

package/src/lexicon/types/com/atproto/admin/queryModerationEvents.ts

@@ -31,6 +31,10 @@ export interface QueryParams {
   addedLabels?: string[]
   /** If specified, only events where all of these labels were removed are returned */
   removedLabels?: string[]
+  /** If specified, only events where all of these tags were added are returned */
+  addedTags?: string[]
+  /** If specified, only events where all of these tags were removed are returned */
+  removedTags?: string[]
   reportTypes?: string[]
   cursor?: string
 }

package/src/lexicon/types/com/atproto/admin/queryModerationStatuses.ts

@@ -35,6 +35,8 @@ export interface QueryParams {
   /** Get subjects in unresolved appealed status */
   appealed?: boolean
   limit: number
+  tags?: string[]
+  excludeTags?: string[]
   cursor?: string
 }
 

package/src/lexicon/types/com/atproto/identity/getRecommendedDidCredentials.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 {
+  /** Recommended rotation keys for PLC dids. Should be undefined (or ignored) for did:webs. */
+  rotationKeys?: string[]
+  alsoKnownAs?: string[]
+  verificationMethods?: {}
+  services?: {}
+  [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/com/atproto/identity/requestPlcOperationSignature.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+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/com/atproto/{temp/transferAccount.ts → identity/signPlcOperation.ts}

@@ -11,17 +11,18 @@ import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
 export interface QueryParams {}
 
 export interface InputSchema {
-  handle: string
-  did: string
-  plcOp: {}
+  /** A token received through com.atproto.identity.requestPlcOperationSignature */
+  token?: string
+  rotationKeys?: string[]
+  alsoKnownAs?: string[]
+  verificationMethods?: {}
+  services?: {}
   [k: string]: unknown
 }
 
 export interface OutputSchema {
-  accessJwt: string
-  refreshJwt: string
-  handle: string
-  did: string
+  /** A signed DID PLC operation. */
+  operation: {}
   [k: string]: unknown
 }
 
@@ -39,14 +40,6 @@ export interface HandlerSuccess {
 export interface HandlerError {
   status: number
   message?: string
-  error?:
-    | 'InvalidHandle'
-    | 'InvalidPassword'
-    | 'InvalidInviteCode'
-    | 'HandleNotAvailable'
-    | 'UnsupportedDomain'
-    | 'UnresolvableDid'
-    | 'IncompatibleDidDoc'
 }
 
 export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough

package/src/lexicon/types/com/atproto/identity/submitPlcOperation.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 {
+  operation: {}
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+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/com/atproto/{temp/pushBlob.ts → repo/importRepo.ts}

@@ -9,15 +9,12 @@ import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
 import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
 
-export interface QueryParams {
-  /** The DID of the repo. */
-  did: string
-}
+export interface QueryParams {}
 
 export type InputSchema = string | Uint8Array
 
 export interface HandlerInput {
-  encoding: '*/*'
+  encoding: 'application/vnd.ipld.car'
   body: stream.Readable
 }
 

package/src/lexicon/types/com/atproto/repo/listMissingBlobs.ts

@@ -0,0 +1,65 @@
+/**
+ * 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 {
+  limit: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  blobs: RecordBlob[]
+  [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
+
+export interface RecordBlob {
+  cid: string
+  recordUri: string
+  [k: string]: unknown
+}
+
+export function isRecordBlob(v: unknown): v is RecordBlob {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'com.atproto.repo.listMissingBlobs#recordBlob'
+  )
+}
+
+export function validateRecordBlob(v: unknown): ValidationResult {
+  return lexicons.validate('com.atproto.repo.listMissingBlobs#recordBlob', v)
+}

package/src/lexicon/types/com/atproto/server/activateAccount.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 type HandlerInput = undefined
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+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/com/atproto/server/checkAccountStatus.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 {
+  activated: boolean
+  validDid: boolean
+  repoCommit: string
+  repoRev: string
+  repoBlocks: number
+  indexedRecords: number
+  privateStateValues: number
+  expectedBlobs: number
+  importedBlobs: number
+  [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/com/atproto/server/deactivateAccount.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 {
+  /** A recommendation to server as to how long they should hold onto the deactivated account before deleting. */
+  deleteAfter?: string
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+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/com/atproto/server/describeServer.ts

@@ -20,6 +20,7 @@ export interface OutputSchema {
   /** List of domain suffixes that can be used in account handles. */
   availableUserDomains: string[]
   links?: Links
+  did: string
   [k: string]: unknown
 }
 

package/src/lexicon/types/com/atproto/{temp/importRepo.ts → server/getServiceAuth.ts}

@@ -2,7 +2,6 @@
  * 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'
@@ -10,20 +9,22 @@ import { CID } from 'multiformats/cid'
 import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
 
 export interface QueryParams {
-  /** The DID of the repo. */
-  did: string
+  /** The DID of the service that the token will be used to authenticate with */
+  aud: string
 }
 
-export type InputSchema = string | Uint8Array
+export type InputSchema = undefined
 
-export interface HandlerInput {
-  encoding: 'application/vnd.ipld.car'
-  body: stream.Readable
+export interface OutputSchema {
+  token: string
+  [k: string]: unknown
 }
 
+export type HandlerInput = undefined
+
 export interface HandlerSuccess {
-  encoding: 'text/plain'
-  body: Uint8Array | stream.Readable
+  encoding: 'application/json'
+  body: OutputSchema
   headers?: { [key: string]: string }
 }
 

package/src/lexicon/types/com/atproto/sync/subscribeRepos.ts

@@ -15,6 +15,7 @@ export interface QueryParams {
 
 export type OutputSchema =
   | Commit
+  | Identity
   | Handle
   | Migrate
   | Tombstone
@@ -71,7 +72,27 @@ export function validateCommit(v: unknown): ValidationResult {
   return lexicons.validate('com.atproto.sync.subscribeRepos#commit', v)
 }
 
-/** Represents an update of the account's handle, or transition to/from invalid state. */
+/** Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache. */
+export interface Identity {
+  seq: number
+  did: string
+  time: string
+  [k: string]: unknown
+}
+
+export function isIdentity(v: unknown): v is Identity {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'com.atproto.sync.subscribeRepos#identity'
+  )
+}
+
+export function validateIdentity(v: unknown): ValidationResult {
+  return lexicons.validate('com.atproto.sync.subscribeRepos#identity', v)
+}
+
+/** Represents an update of the account's handle, or transition to/from invalid state. NOTE: Will be deprecated in favor of #identity. */
 export interface Handle {
   seq: number
   did: string
@@ -92,7 +113,7 @@ export function validateHandle(v: unknown): ValidationResult {
   return lexicons.validate('com.atproto.sync.subscribeRepos#handle', v)
 }
 
-/** Represents an account moving from one PDS instance to another. NOTE: not implemented; full account migration may introduce a new message instead. */
+/** Represents an account moving from one PDS instance to another. NOTE: not implemented; account migration uses #identity instead */
 export interface Migrate {
   seq: number
   did: string
@@ -113,7 +134,7 @@ export function validateMigrate(v: unknown): ValidationResult {
   return lexicons.validate('com.atproto.sync.subscribeRepos#migrate', v)
 }
 
-/** Indicates that an account has been deleted. */
+/** Indicates that an account has been deleted. NOTE: may be deprecated in favor of #identity or a future #account event */
 export interface Tombstone {
   seq: number
   did: string

package/tests/auto-moderator/labeler.test.ts

@@ -39,10 +39,11 @@ describe('labeler', () => {
     alice = sc.dids.alice
     const storeBlob = (bytes: Uint8Array) => {
       return pdsCtx.actorStore.transact(alice, async (store) => {
-        const blobRef = await store.repo.blob.addUntetheredBlob(
+        const metadata = await store.repo.blob.uploadBlobAndGetMetadata(
           'image/jpeg',
           Readable.from([bytes], { objectMode: false }),
         )
+        const blobRef = await store.repo.blob.trackUntetheredBlob(metadata)
         const preparedBlobRef = {
           cid: blobRef.ref,
           mimeType: 'image/jpeg',
@@ -105,6 +106,8 @@ describe('labeler', () => {
       types: [],
       addedLabels: [],
       removedLabels: [],
+      addedTags: [],
+      removedTags: [],
     })
     expect(events.length).toBe(1)
     expect(events[0]).toMatchObject({