@atproto/bsky 0.0.152 → 0.0.154

package/src/lexicon/types/app/bsky/unspecced/getPostThreadV2.ts

@@ -12,6 +12,7 @@ import {
 } from '../../../../util'
 import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
 import type * as AppBskyFeedDefs from '../feed/defs.js'
+import type * as AppBskyUnspeccedDefs from './defs.js'
 
 const is$typed = _is$typed,
   validate = _validate
@@ -74,10 +75,10 @@ export interface ThreadItem {
   /** The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths. */
   depth: number
   value:
-    | $Typed<ThreadItemPost>
-    | $Typed<ThreadItemNoUnauthenticated>
-    | $Typed<ThreadItemNotFound>
-    | $Typed<ThreadItemBlocked>
+    | $Typed<AppBskyUnspeccedDefs.ThreadItemPost>
+    | $Typed<AppBskyUnspeccedDefs.ThreadItemNoUnauthenticated>
+    | $Typed<AppBskyUnspeccedDefs.ThreadItemNotFound>
+    | $Typed<AppBskyUnspeccedDefs.ThreadItemBlocked>
     | { $type: string }
 }
 
@@ -90,71 +91,3 @@ export function isThreadItem<V>(v: V) {
 export function validateThreadItem<V>(v: V) {
   return validate<ThreadItem & V>(v, id, hashThreadItem)
 }
-
-export interface ThreadItemPost {
-  $type?: 'app.bsky.unspecced.getPostThreadV2#threadItemPost'
-  post: AppBskyFeedDefs.PostView
-  /** This post has more parents that were not present in the response. This is just a boolean, without the number of parents. */
-  moreParents: boolean
-  /** This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate. */
-  moreReplies: number
-  /** This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread. */
-  opThread: boolean
-}
-
-const hashThreadItemPost = 'threadItemPost'
-
-export function isThreadItemPost<V>(v: V) {
-  return is$typed(v, id, hashThreadItemPost)
-}
-
-export function validateThreadItemPost<V>(v: V) {
-  return validate<ThreadItemPost & V>(v, id, hashThreadItemPost)
-}
-
-export interface ThreadItemNoUnauthenticated {
-  $type?: 'app.bsky.unspecced.getPostThreadV2#threadItemNoUnauthenticated'
-}
-
-const hashThreadItemNoUnauthenticated = 'threadItemNoUnauthenticated'
-
-export function isThreadItemNoUnauthenticated<V>(v: V) {
-  return is$typed(v, id, hashThreadItemNoUnauthenticated)
-}
-
-export function validateThreadItemNoUnauthenticated<V>(v: V) {
-  return validate<ThreadItemNoUnauthenticated & V>(
-    v,
-    id,
-    hashThreadItemNoUnauthenticated,
-  )
-}
-
-export interface ThreadItemNotFound {
-  $type?: 'app.bsky.unspecced.getPostThreadV2#threadItemNotFound'
-}
-
-const hashThreadItemNotFound = 'threadItemNotFound'
-
-export function isThreadItemNotFound<V>(v: V) {
-  return is$typed(v, id, hashThreadItemNotFound)
-}
-
-export function validateThreadItemNotFound<V>(v: V) {
-  return validate<ThreadItemNotFound & V>(v, id, hashThreadItemNotFound)
-}
-
-export interface ThreadItemBlocked {
-  $type?: 'app.bsky.unspecced.getPostThreadV2#threadItemBlocked'
-  author: AppBskyFeedDefs.BlockedAuthor
-}
-
-const hashThreadItemBlocked = 'threadItemBlocked'
-
-export function isThreadItemBlocked<V>(v: V) {
-  return is$typed(v, id, hashThreadItemBlocked)
-}
-
-export function validateThreadItemBlocked<V>(v: V) {
-  return validate<ThreadItemBlocked & V>(v, id, hashThreadItemBlocked)
-}

package/src/proto/bsky_pb.ts

@@ -90,6 +90,11 @@ export class Record extends Message<Record> {
    */
   takedownRef = ''
 
+  /**
+   * @generated from field: repeated string tags = 9;
+   */
+  tags: string[] = []
+
   constructor(data?: PartialMessage<Record>) {
     super()
     proto3.util.initPartial(data, this)
@@ -110,6 +115,13 @@ export class Record extends Message<Record> {
       kind: 'scalar',
       T: 9 /* ScalarType.STRING */,
     },
+    {
+      no: 9,
+      name: 'tags',
+      kind: 'scalar',
+      T: 9 /* ScalarType.STRING */,
+      repeated: true,
+    },
   ])
 
   static fromBinary(

package/src/proto/bsync_connect.ts

@@ -10,10 +10,14 @@ import {
   AddNotifOperationResponse,
   PingRequest,
   PingResponse,
+  PutOperationRequest,
+  PutOperationResponse,
   ScanMuteOperationsRequest,
   ScanMuteOperationsResponse,
   ScanNotifOperationsRequest,
   ScanNotifOperationsResponse,
+  ScanOperationsRequest,
+  ScanOperationsResponse,
 } from './bsync_pb'
 import { MethodKind } from '@bufbuild/protobuf'
 
@@ -61,6 +65,24 @@ export const Service = {
       O: ScanNotifOperationsResponse,
       kind: MethodKind.Unary,
     },
+    /**
+     * @generated from rpc bsync.Service.PutOperation
+     */
+    putOperation: {
+      name: 'PutOperation',
+      I: PutOperationRequest,
+      O: PutOperationResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc bsync.Service.ScanOperations
+     */
+    scanOperations: {
+      name: 'ScanOperations',
+      I: ScanOperationsRequest,
+      O: ScanOperationsResponse,
+      kind: MethodKind.Unary,
+    },
     /**
      * Ping
      *

package/src/proto/bsync_pb.ts

@@ -13,6 +13,38 @@ import type {
 } from '@bufbuild/protobuf'
 import { Message, proto3 } from '@bufbuild/protobuf'
 
+/**
+ * @generated from enum bsync.Method
+ */
+export enum Method {
+  /**
+   * @generated from enum value: METHOD_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: METHOD_CREATE = 1;
+   */
+  CREATE = 1,
+
+  /**
+   * @generated from enum value: METHOD_UPDATE = 2;
+   */
+  UPDATE = 2,
+
+  /**
+   * @generated from enum value: METHOD_DELETE = 3;
+   */
+  DELETE = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Method)
+proto3.util.setEnumType(Method, 'bsync.Method', [
+  { no: 0, name: 'METHOD_UNSPECIFIED' },
+  { no: 1, name: 'METHOD_CREATE' },
+  { no: 2, name: 'METHOD_UPDATE' },
+  { no: 3, name: 'METHOD_DELETE' },
+])
+
 /**
  * @generated from message bsync.MuteOperation
  */
@@ -689,6 +721,329 @@ export class ScanNotifOperationsResponse extends Message<ScanNotifOperationsResp
   }
 }
 
+/**
+ * @generated from message bsync.Operation
+ */
+export class Operation extends Message<Operation> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = ''
+
+  /**
+   * @generated from field: string actor_did = 2;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: string collection = 3;
+   */
+  collection = ''
+
+  /**
+   * @generated from field: string rkey = 4;
+   */
+  rkey = ''
+
+  /**
+   * @generated from field: bsync.Method method = 5;
+   */
+  method = Method.UNSPECIFIED
+
+  /**
+   * @generated from field: bytes payload = 6;
+   */
+  payload = new Uint8Array(0)
+
+  constructor(data?: PartialMessage<Operation>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.Operation'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'collection', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: 'rkey', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: 'method', kind: 'enum', T: proto3.getEnumType(Method) },
+    { no: 6, name: 'payload', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): Operation {
+    return new Operation().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): Operation {
+    return new Operation().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): Operation {
+    return new Operation().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: Operation | PlainMessage<Operation> | undefined,
+    b: Operation | PlainMessage<Operation> | undefined,
+  ): boolean {
+    return proto3.util.equals(Operation, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.PutOperationRequest
+ */
+export class PutOperationRequest extends Message<PutOperationRequest> {
+  /**
+   * @generated from field: string collection = 1;
+   */
+  collection = ''
+
+  /**
+   * @generated from field: string actor_did = 2;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: string rkey = 3;
+   */
+  rkey = ''
+
+  /**
+   * @generated from field: bsync.Method method = 4;
+   */
+  method = Method.UNSPECIFIED
+
+  /**
+   * @generated from field: bytes payload = 5;
+   */
+  payload = new Uint8Array(0)
+
+  constructor(data?: PartialMessage<PutOperationRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.PutOperationRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'collection', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'rkey', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: 'method', kind: 'enum', T: proto3.getEnumType(Method) },
+    { no: 5, name: 'payload', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PutOperationRequest {
+    return new PutOperationRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationRequest {
+    return new PutOperationRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationRequest {
+    return new PutOperationRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: PutOperationRequest | PlainMessage<PutOperationRequest> | undefined,
+    b: PutOperationRequest | PlainMessage<PutOperationRequest> | undefined,
+  ): boolean {
+    return proto3.util.equals(PutOperationRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.PutOperationResponse
+ */
+export class PutOperationResponse extends Message<PutOperationResponse> {
+  /**
+   * @generated from field: bsync.Operation operation = 1;
+   */
+  operation?: Operation
+
+  constructor(data?: PartialMessage<PutOperationResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.PutOperationResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'operation', kind: 'message', T: Operation },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PutOperationResponse {
+    return new PutOperationResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationResponse {
+    return new PutOperationResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationResponse {
+    return new PutOperationResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: PutOperationResponse | PlainMessage<PutOperationResponse> | undefined,
+    b: PutOperationResponse | PlainMessage<PutOperationResponse> | undefined,
+  ): boolean {
+    return proto3.util.equals(PutOperationResponse, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.ScanOperationsRequest
+ */
+export class ScanOperationsRequest extends Message<ScanOperationsRequest> {
+  /**
+   * @generated from field: string cursor = 1;
+   */
+  cursor = ''
+
+  /**
+   * @generated from field: int32 limit = 2;
+   */
+  limit = 0
+
+  constructor(data?: PartialMessage<ScanOperationsRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.ScanOperationsRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'limit', kind: 'scalar', T: 5 /* ScalarType.INT32 */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): ScanOperationsRequest {
+    return new ScanOperationsRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsRequest {
+    return new ScanOperationsRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsRequest {
+    return new ScanOperationsRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: ScanOperationsRequest | PlainMessage<ScanOperationsRequest> | undefined,
+    b: ScanOperationsRequest | PlainMessage<ScanOperationsRequest> | undefined,
+  ): boolean {
+    return proto3.util.equals(ScanOperationsRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.ScanOperationsResponse
+ */
+export class ScanOperationsResponse extends Message<ScanOperationsResponse> {
+  /**
+   * @generated from field: repeated bsync.Operation operations = 1;
+   */
+  operations: Operation[] = []
+
+  /**
+   * @generated from field: string cursor = 2;
+   */
+  cursor = ''
+
+  constructor(data?: PartialMessage<ScanOperationsResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.ScanOperationsResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: 'operations',
+      kind: 'message',
+      T: Operation,
+      repeated: true,
+    },
+    { no: 2, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): ScanOperationsResponse {
+    return new ScanOperationsResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsResponse {
+    return new ScanOperationsResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsResponse {
+    return new ScanOperationsResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | ScanOperationsResponse
+      | PlainMessage<ScanOperationsResponse>
+      | undefined,
+    b:
+      | ScanOperationsResponse
+      | PlainMessage<ScanOperationsResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(ScanOperationsResponse, a, b)
+  }
+}
+
 /**
  * Ping
  *