@atproto/bsky 0.0.187 → 0.0.189

package/src/proto/bsync_pb.ts

@@ -3,15 +3,8 @@
 /* eslint-disable */
 // @ts-nocheck
 
-import type {
-  BinaryReadOptions,
-  FieldList,
-  JsonReadOptions,
-  JsonValue,
-  PartialMessage,
-  PlainMessage,
-} from '@bufbuild/protobuf'
-import { Message, proto3 } from '@bufbuild/protobuf'
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3 } from "@bufbuild/protobuf";
 
 /**
  * @generated from enum bsync.Method
@@ -38,12 +31,12 @@ export enum Method {
   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' },
-])
+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
@@ -52,68 +45,51 @@ export class MuteOperation extends Message<MuteOperation> {
   /**
    * @generated from field: string id = 1;
    */
-  id = ''
+  id = "";
 
   /**
    * @generated from field: bsync.MuteOperation.Type type = 2;
    */
-  type = MuteOperation_Type.UNSPECIFIED
+  type = MuteOperation_Type.UNSPECIFIED;
 
   /**
    * @generated from field: string actor_did = 3;
    */
-  actorDid = ''
+  actorDid = "";
 
   /**
    * @generated from field: string subject = 4;
    */
-  subject = ''
+  subject = "";
 
   constructor(data?: PartialMessage<MuteOperation>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.MuteOperation'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.MuteOperation";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: 'id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    {
-      no: 2,
-      name: 'type',
-      kind: 'enum',
-      T: proto3.getEnumType(MuteOperation_Type),
-    },
-    { no: 3, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: 'subject', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): MuteOperation {
-    return new MuteOperation().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): MuteOperation {
-    return new MuteOperation().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): MuteOperation {
-    return new MuteOperation().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a: MuteOperation | PlainMessage<MuteOperation> | undefined,
-    b: MuteOperation | PlainMessage<MuteOperation> | undefined,
-  ): boolean {
-    return proto3.util.equals(MuteOperation, a, b)
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "type", kind: "enum", T: proto3.getEnumType(MuteOperation_Type) },
+    { no: 3, name: "actor_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "subject", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MuteOperation {
+    return new MuteOperation().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MuteOperation {
+    return new MuteOperation().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MuteOperation {
+    return new MuteOperation().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MuteOperation | PlainMessage<MuteOperation> | undefined, b: MuteOperation | PlainMessage<MuteOperation> | undefined): boolean {
+    return proto3.util.equals(MuteOperation, a, b);
   }
 }
 
@@ -142,12 +118,12 @@ export enum MuteOperation_Type {
   CLEAR = 3,
 }
 // Retrieve enum metadata with: proto3.getEnumType(MuteOperation_Type)
-proto3.util.setEnumType(MuteOperation_Type, 'bsync.MuteOperation.Type', [
-  { no: 0, name: 'TYPE_UNSPECIFIED' },
-  { no: 1, name: 'TYPE_ADD' },
-  { no: 2, name: 'TYPE_REMOVE' },
-  { no: 3, name: 'TYPE_CLEAR' },
-])
+proto3.util.setEnumType(MuteOperation_Type, "bsync.MuteOperation.Type", [
+  { no: 0, name: "TYPE_UNSPECIFIED" },
+  { no: 1, name: "TYPE_ADD" },
+  { no: 2, name: "TYPE_REMOVE" },
+  { no: 3, name: "TYPE_CLEAR" },
+]);
 
 /**
  * @generated from message bsync.AddMuteOperationRequest
@@ -156,68 +132,45 @@ export class AddMuteOperationRequest extends Message<AddMuteOperationRequest> {
   /**
    * @generated from field: bsync.MuteOperation.Type type = 1;
    */
-  type = MuteOperation_Type.UNSPECIFIED
+  type = MuteOperation_Type.UNSPECIFIED;
 
   /**
    * @generated from field: string actor_did = 2;
    */
-  actorDid = ''
+  actorDid = "";
 
   /**
    * @generated from field: string subject = 3;
    */
-  subject = ''
+  subject = "";
 
   constructor(data?: PartialMessage<AddMuteOperationRequest>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.AddMuteOperationRequest'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.AddMuteOperationRequest";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: 'type',
-      kind: 'enum',
-      T: proto3.getEnumType(MuteOperation_Type),
-    },
-    { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: 'subject', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): AddMuteOperationRequest {
-    return new AddMuteOperationRequest().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): AddMuteOperationRequest {
-    return new AddMuteOperationRequest().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): AddMuteOperationRequest {
-    return new AddMuteOperationRequest().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | AddMuteOperationRequest
-      | PlainMessage<AddMuteOperationRequest>
-      | undefined,
-    b:
-      | AddMuteOperationRequest
-      | PlainMessage<AddMuteOperationRequest>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(AddMuteOperationRequest, a, b)
+    { no: 1, name: "type", kind: "enum", T: proto3.getEnumType(MuteOperation_Type) },
+    { no: 2, name: "actor_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "subject", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddMuteOperationRequest {
+    return new AddMuteOperationRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddMuteOperationRequest {
+    return new AddMuteOperationRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddMuteOperationRequest {
+    return new AddMuteOperationRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AddMuteOperationRequest | PlainMessage<AddMuteOperationRequest> | undefined, b: AddMuteOperationRequest | PlainMessage<AddMuteOperationRequest> | undefined): boolean {
+    return proto3.util.equals(AddMuteOperationRequest, a, b);
   }
 }
 
@@ -228,51 +181,33 @@ export class AddMuteOperationResponse extends Message<AddMuteOperationResponse>
   /**
    * @generated from field: bsync.MuteOperation operation = 1;
    */
-  operation?: MuteOperation
+  operation?: MuteOperation;
 
   constructor(data?: PartialMessage<AddMuteOperationResponse>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.AddMuteOperationResponse'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.AddMuteOperationResponse";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: 'operation', kind: 'message', T: MuteOperation },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): AddMuteOperationResponse {
-    return new AddMuteOperationResponse().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): AddMuteOperationResponse {
-    return new AddMuteOperationResponse().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): AddMuteOperationResponse {
-    return new AddMuteOperationResponse().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | AddMuteOperationResponse
-      | PlainMessage<AddMuteOperationResponse>
-      | undefined,
-    b:
-      | AddMuteOperationResponse
-      | PlainMessage<AddMuteOperationResponse>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(AddMuteOperationResponse, a, b)
+    { no: 1, name: "operation", kind: "message", T: MuteOperation },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddMuteOperationResponse {
+    return new AddMuteOperationResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddMuteOperationResponse {
+    return new AddMuteOperationResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddMuteOperationResponse {
+    return new AddMuteOperationResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AddMuteOperationResponse | PlainMessage<AddMuteOperationResponse> | undefined, b: AddMuteOperationResponse | PlainMessage<AddMuteOperationResponse> | undefined): boolean {
+    return proto3.util.equals(AddMuteOperationResponse, a, b);
   }
 }
 
@@ -283,57 +218,39 @@ export class ScanMuteOperationsRequest extends Message<ScanMuteOperationsRequest
   /**
    * @generated from field: string cursor = 1;
    */
-  cursor = ''
+  cursor = "";
 
   /**
    * @generated from field: int32 limit = 2;
    */
-  limit = 0
+  limit = 0;
 
   constructor(data?: PartialMessage<ScanMuteOperationsRequest>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.ScanMuteOperationsRequest'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.ScanMuteOperationsRequest";
   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>,
-  ): ScanMuteOperationsRequest {
-    return new ScanMuteOperationsRequest().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): ScanMuteOperationsRequest {
-    return new ScanMuteOperationsRequest().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): ScanMuteOperationsRequest {
-    return new ScanMuteOperationsRequest().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | ScanMuteOperationsRequest
-      | PlainMessage<ScanMuteOperationsRequest>
-      | undefined,
-    b:
-      | ScanMuteOperationsRequest
-      | PlainMessage<ScanMuteOperationsRequest>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(ScanMuteOperationsRequest, a, b)
+    { 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>): ScanMuteOperationsRequest {
+    return new ScanMuteOperationsRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanMuteOperationsRequest {
+    return new ScanMuteOperationsRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanMuteOperationsRequest {
+    return new ScanMuteOperationsRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ScanMuteOperationsRequest | PlainMessage<ScanMuteOperationsRequest> | undefined, b: ScanMuteOperationsRequest | PlainMessage<ScanMuteOperationsRequest> | undefined): boolean {
+    return proto3.util.equals(ScanMuteOperationsRequest, a, b);
   }
 }
 
@@ -344,63 +261,39 @@ export class ScanMuteOperationsResponse extends Message<ScanMuteOperationsRespon
   /**
    * @generated from field: repeated bsync.MuteOperation operations = 1;
    */
-  operations: MuteOperation[] = []
+  operations: MuteOperation[] = [];
 
   /**
    * @generated from field: string cursor = 2;
    */
-  cursor = ''
+  cursor = "";
 
   constructor(data?: PartialMessage<ScanMuteOperationsResponse>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.ScanMuteOperationsResponse'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.ScanMuteOperationsResponse";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: 'operations',
-      kind: 'message',
-      T: MuteOperation,
-      repeated: true,
-    },
-    { no: 2, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): ScanMuteOperationsResponse {
-    return new ScanMuteOperationsResponse().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): ScanMuteOperationsResponse {
-    return new ScanMuteOperationsResponse().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): ScanMuteOperationsResponse {
-    return new ScanMuteOperationsResponse().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | ScanMuteOperationsResponse
-      | PlainMessage<ScanMuteOperationsResponse>
-      | undefined,
-    b:
-      | ScanMuteOperationsResponse
-      | PlainMessage<ScanMuteOperationsResponse>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(ScanMuteOperationsResponse, a, b)
+    { no: 1, name: "operations", kind: "message", T: MuteOperation, repeated: true },
+    { no: 2, name: "cursor", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ScanMuteOperationsResponse {
+    return new ScanMuteOperationsResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanMuteOperationsResponse {
+    return new ScanMuteOperationsResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanMuteOperationsResponse {
+    return new ScanMuteOperationsResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ScanMuteOperationsResponse | PlainMessage<ScanMuteOperationsResponse> | undefined, b: ScanMuteOperationsResponse | PlainMessage<ScanMuteOperationsResponse> | undefined): boolean {
+    return proto3.util.equals(ScanMuteOperationsResponse, a, b);
   }
 }
 
@@ -411,63 +304,45 @@ export class NotifOperation extends Message<NotifOperation> {
   /**
    * @generated from field: string id = 1;
    */
-  id = ''
+  id = "";
 
   /**
    * @generated from field: string actor_did = 2;
    */
-  actorDid = ''
+  actorDid = "";
 
   /**
    * @generated from field: optional bool priority = 3;
    */
-  priority?: boolean
+  priority?: boolean;
 
   constructor(data?: PartialMessage<NotifOperation>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.NotifOperation'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.NotifOperation";
   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: 'priority',
-      kind: 'scalar',
-      T: 8 /* ScalarType.BOOL */,
-      opt: true,
-    },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): NotifOperation {
-    return new NotifOperation().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): NotifOperation {
-    return new NotifOperation().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): NotifOperation {
-    return new NotifOperation().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a: NotifOperation | PlainMessage<NotifOperation> | undefined,
-    b: NotifOperation | PlainMessage<NotifOperation> | undefined,
-  ): boolean {
-    return proto3.util.equals(NotifOperation, a, b)
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "actor_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "priority", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NotifOperation {
+    return new NotifOperation().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NotifOperation {
+    return new NotifOperation().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NotifOperation {
+    return new NotifOperation().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: NotifOperation | PlainMessage<NotifOperation> | undefined, b: NotifOperation | PlainMessage<NotifOperation> | undefined): boolean {
+    return proto3.util.equals(NotifOperation, a, b);
   }
 }
 
@@ -478,63 +353,39 @@ export class AddNotifOperationRequest extends Message<AddNotifOperationRequest>
   /**
    * @generated from field: string actor_did = 1;
    */
-  actorDid = ''
+  actorDid = "";
 
   /**
    * @generated from field: optional bool priority = 2;
    */
-  priority?: boolean
+  priority?: boolean;
 
   constructor(data?: PartialMessage<AddNotifOperationRequest>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.AddNotifOperationRequest'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.AddNotifOperationRequest";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    {
-      no: 2,
-      name: 'priority',
-      kind: 'scalar',
-      T: 8 /* ScalarType.BOOL */,
-      opt: true,
-    },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): AddNotifOperationRequest {
-    return new AddNotifOperationRequest().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): AddNotifOperationRequest {
-    return new AddNotifOperationRequest().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): AddNotifOperationRequest {
-    return new AddNotifOperationRequest().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | AddNotifOperationRequest
-      | PlainMessage<AddNotifOperationRequest>
-      | undefined,
-    b:
-      | AddNotifOperationRequest
-      | PlainMessage<AddNotifOperationRequest>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(AddNotifOperationRequest, a, b)
+    { no: 1, name: "actor_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "priority", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddNotifOperationRequest {
+    return new AddNotifOperationRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddNotifOperationRequest {
+    return new AddNotifOperationRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddNotifOperationRequest {
+    return new AddNotifOperationRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AddNotifOperationRequest | PlainMessage<AddNotifOperationRequest> | undefined, b: AddNotifOperationRequest | PlainMessage<AddNotifOperationRequest> | undefined): boolean {
+    return proto3.util.equals(AddNotifOperationRequest, a, b);
   }
 }
 
@@ -545,51 +396,33 @@ export class AddNotifOperationResponse extends Message<AddNotifOperationResponse
   /**
    * @generated from field: bsync.NotifOperation operation = 1;
    */
-  operation?: NotifOperation
+  operation?: NotifOperation;
 
   constructor(data?: PartialMessage<AddNotifOperationResponse>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.AddNotifOperationResponse'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.AddNotifOperationResponse";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: 'operation', kind: 'message', T: NotifOperation },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): AddNotifOperationResponse {
-    return new AddNotifOperationResponse().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): AddNotifOperationResponse {
-    return new AddNotifOperationResponse().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): AddNotifOperationResponse {
-    return new AddNotifOperationResponse().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | AddNotifOperationResponse
-      | PlainMessage<AddNotifOperationResponse>
-      | undefined,
-    b:
-      | AddNotifOperationResponse
-      | PlainMessage<AddNotifOperationResponse>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(AddNotifOperationResponse, a, b)
+    { no: 1, name: "operation", kind: "message", T: NotifOperation },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddNotifOperationResponse {
+    return new AddNotifOperationResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddNotifOperationResponse {
+    return new AddNotifOperationResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddNotifOperationResponse {
+    return new AddNotifOperationResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: AddNotifOperationResponse | PlainMessage<AddNotifOperationResponse> | undefined, b: AddNotifOperationResponse | PlainMessage<AddNotifOperationResponse> | undefined): boolean {
+    return proto3.util.equals(AddNotifOperationResponse, a, b);
   }
 }
 
@@ -600,57 +433,39 @@ export class ScanNotifOperationsRequest extends Message<ScanNotifOperationsReque
   /**
    * @generated from field: string cursor = 1;
    */
-  cursor = ''
+  cursor = "";
 
   /**
    * @generated from field: int32 limit = 2;
    */
-  limit = 0
+  limit = 0;
 
   constructor(data?: PartialMessage<ScanNotifOperationsRequest>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.ScanNotifOperationsRequest'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.ScanNotifOperationsRequest";
   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>,
-  ): ScanNotifOperationsRequest {
-    return new ScanNotifOperationsRequest().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): ScanNotifOperationsRequest {
-    return new ScanNotifOperationsRequest().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): ScanNotifOperationsRequest {
-    return new ScanNotifOperationsRequest().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | ScanNotifOperationsRequest
-      | PlainMessage<ScanNotifOperationsRequest>
-      | undefined,
-    b:
-      | ScanNotifOperationsRequest
-      | PlainMessage<ScanNotifOperationsRequest>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(ScanNotifOperationsRequest, a, b)
+    { 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>): ScanNotifOperationsRequest {
+    return new ScanNotifOperationsRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanNotifOperationsRequest {
+    return new ScanNotifOperationsRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanNotifOperationsRequest {
+    return new ScanNotifOperationsRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ScanNotifOperationsRequest | PlainMessage<ScanNotifOperationsRequest> | undefined, b: ScanNotifOperationsRequest | PlainMessage<ScanNotifOperationsRequest> | undefined): boolean {
+    return proto3.util.equals(ScanNotifOperationsRequest, a, b);
   }
 }
 
@@ -661,63 +476,39 @@ export class ScanNotifOperationsResponse extends Message<ScanNotifOperationsResp
   /**
    * @generated from field: repeated bsync.NotifOperation operations = 1;
    */
-  operations: NotifOperation[] = []
+  operations: NotifOperation[] = [];
 
   /**
    * @generated from field: string cursor = 2;
    */
-  cursor = ''
+  cursor = "";
 
   constructor(data?: PartialMessage<ScanNotifOperationsResponse>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.ScanNotifOperationsResponse'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.ScanNotifOperationsResponse";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    {
-      no: 1,
-      name: 'operations',
-      kind: 'message',
-      T: NotifOperation,
-      repeated: true,
-    },
-    { no: 2, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-  ])
-
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): ScanNotifOperationsResponse {
-    return new ScanNotifOperationsResponse().fromBinary(bytes, options)
-  }
-
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): ScanNotifOperationsResponse {
-    return new ScanNotifOperationsResponse().fromJson(jsonValue, options)
-  }
-
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): ScanNotifOperationsResponse {
-    return new ScanNotifOperationsResponse().fromJsonString(jsonString, options)
-  }
-
-  static equals(
-    a:
-      | ScanNotifOperationsResponse
-      | PlainMessage<ScanNotifOperationsResponse>
-      | undefined,
-    b:
-      | ScanNotifOperationsResponse
-      | PlainMessage<ScanNotifOperationsResponse>
-      | undefined,
-  ): boolean {
-    return proto3.util.equals(ScanNotifOperationsResponse, a, b)
+    { no: 1, name: "operations", kind: "message", T: NotifOperation, repeated: true },
+    { no: 2, name: "cursor", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ScanNotifOperationsResponse {
+    return new ScanNotifOperationsResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanNotifOperationsResponse {
+    return new ScanNotifOperationsResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanNotifOperationsResponse {
+    return new ScanNotifOperationsResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ScanNotifOperationsResponse | PlainMessage<ScanNotifOperationsResponse> | undefined, b: ScanNotifOperationsResponse | PlainMessage<ScanNotifOperationsResponse> | undefined): boolean {
+    return proto3.util.equals(ScanNotifOperationsResponse, a, b);
   }
 }
 
@@ -728,75 +519,63 @@ export class Operation extends Message<Operation> {
   /**
    * @generated from field: string id = 1;
    */
-  id = ''
+  id = "";
 
   /**
    * @generated from field: string actor_did = 2;
    */
-  actorDid = ''
+  actorDid = "";
 
   /**
    * @generated from field: string namespace = 3;
    */
-  namespace = ''
+  namespace = "";
 
   /**
    * @generated from field: string key = 4;
    */
-  key = ''
+  key = "";
 
   /**
    * @generated from field: bsync.Method method = 5;
    */
-  method = Method.UNSPECIFIED
+  method = Method.UNSPECIFIED;
 
   /**
    * @generated from field: bytes payload = 6;
    */
-  payload = new Uint8Array(0)
+  payload = new Uint8Array(0);
 
   constructor(data?: PartialMessage<Operation>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.Operation'
+  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: 'namespace', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 4, name: 'key', 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 */ },
-  ])
+    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "actor_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "namespace", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: "key", 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 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 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 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)
+  static equals(a: Operation | PlainMessage<Operation> | undefined, b: Operation | PlainMessage<Operation> | undefined): boolean {
+    return proto3.util.equals(Operation, a, b);
   }
 }
 
@@ -807,69 +586,57 @@ export class PutOperationRequest extends Message<PutOperationRequest> {
   /**
    * @generated from field: string actor_did = 1;
    */
-  actorDid = ''
+  actorDid = "";
 
   /**
    * @generated from field: string namespace = 2;
    */
-  namespace = ''
+  namespace = "";
 
   /**
    * @generated from field: string key = 3;
    */
-  key = ''
+  key = "";
 
   /**
    * @generated from field: bsync.Method method = 4;
    */
-  method = Method.UNSPECIFIED
+  method = Method.UNSPECIFIED;
 
   /**
    * @generated from field: bytes payload = 5;
    */
-  payload = new Uint8Array(0)
+  payload = new Uint8Array(0);
 
   constructor(data?: PartialMessage<PutOperationRequest>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.PutOperationRequest'
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.PutOperationRequest";
   static readonly fields: FieldList = proto3.util.newFieldList(() => [
-    { no: 1, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 2, name: 'namespace', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
-    { no: 3, name: 'key', 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 */ },
-  ])
+    { no: 1, name: "actor_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "namespace", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: "key", 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 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 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 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)
+  static equals(a: PutOperationRequest | PlainMessage<PutOperationRequest> | undefined, b: PutOperationRequest | PlainMessage<PutOperationRequest> | undefined): boolean {
+    return proto3.util.equals(PutOperationRequest, a, b);
   }
 }
 
@@ -880,45 +647,33 @@ export class PutOperationResponse extends Message<PutOperationResponse> {
   /**
    * @generated from field: bsync.Operation operation = 1;
    */
-  operation?: Operation
+  operation?: Operation;
 
   constructor(data?: PartialMessage<PutOperationResponse>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.PutOperationResponse'
+  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 },
-  ])
+    { no: 1, name: "operation", kind: "message", T: Operation },
+  ]);
 
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): PutOperationResponse {
-    return new PutOperationResponse().fromBinary(bytes, options)
+  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 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 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)
+  static equals(a: PutOperationResponse | PlainMessage<PutOperationResponse> | undefined, b: PutOperationResponse | PlainMessage<PutOperationResponse> | undefined): boolean {
+    return proto3.util.equals(PutOperationResponse, a, b);
   }
 }
 
@@ -929,51 +684,39 @@ export class ScanOperationsRequest extends Message<ScanOperationsRequest> {
   /**
    * @generated from field: string cursor = 1;
    */
-  cursor = ''
+  cursor = "";
 
   /**
    * @generated from field: int32 limit = 2;
    */
-  limit = 0
+  limit = 0;
 
   constructor(data?: PartialMessage<ScanOperationsRequest>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.ScanOperationsRequest'
+  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 */ },
-  ])
+    { 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 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 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 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)
+  static equals(a: ScanOperationsRequest | PlainMessage<ScanOperationsRequest> | undefined, b: ScanOperationsRequest | PlainMessage<ScanOperationsRequest> | undefined): boolean {
+    return proto3.util.equals(ScanOperationsRequest, a, b);
   }
 }
 
@@ -984,63 +727,39 @@ export class ScanOperationsResponse extends Message<ScanOperationsResponse> {
   /**
    * @generated from field: repeated bsync.Operation operations = 1;
    */
-  operations: Operation[] = []
+  operations: Operation[] = [];
 
   /**
    * @generated from field: string cursor = 2;
    */
-  cursor = ''
+  cursor = "";
 
   constructor(data?: PartialMessage<ScanOperationsResponse>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.ScanOperationsResponse'
+  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)
+    { 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);
   }
 }
 
@@ -1051,40 +770,29 @@ export class ScanOperationsResponse extends Message<ScanOperationsResponse> {
  */
 export class PingRequest extends Message<PingRequest> {
   constructor(data?: PartialMessage<PingRequest>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.PingRequest'
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [])
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.PingRequest";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
 
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): PingRequest {
-    return new PingRequest().fromBinary(bytes, options)
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PingRequest {
+    return new PingRequest().fromBinary(bytes, options);
   }
 
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): PingRequest {
-    return new PingRequest().fromJson(jsonValue, options)
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PingRequest {
+    return new PingRequest().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): PingRequest {
-    return new PingRequest().fromJsonString(jsonString, options)
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PingRequest {
+    return new PingRequest().fromJsonString(jsonString, options);
   }
 
-  static equals(
-    a: PingRequest | PlainMessage<PingRequest> | undefined,
-    b: PingRequest | PlainMessage<PingRequest> | undefined,
-  ): boolean {
-    return proto3.util.equals(PingRequest, a, b)
+  static equals(a: PingRequest | PlainMessage<PingRequest> | undefined, b: PingRequest | PlainMessage<PingRequest> | undefined): boolean {
+    return proto3.util.equals(PingRequest, a, b);
   }
 }
 
@@ -1093,39 +801,29 @@ export class PingRequest extends Message<PingRequest> {
  */
 export class PingResponse extends Message<PingResponse> {
   constructor(data?: PartialMessage<PingResponse>) {
-    super()
-    proto3.util.initPartial(data, this)
+    super();
+    proto3.util.initPartial(data, this);
   }
 
-  static readonly runtime: typeof proto3 = proto3
-  static readonly typeName = 'bsync.PingResponse'
-  static readonly fields: FieldList = proto3.util.newFieldList(() => [])
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "bsync.PingResponse";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
 
-  static fromBinary(
-    bytes: Uint8Array,
-    options?: Partial<BinaryReadOptions>,
-  ): PingResponse {
-    return new PingResponse().fromBinary(bytes, options)
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PingResponse {
+    return new PingResponse().fromBinary(bytes, options);
   }
 
-  static fromJson(
-    jsonValue: JsonValue,
-    options?: Partial<JsonReadOptions>,
-  ): PingResponse {
-    return new PingResponse().fromJson(jsonValue, options)
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PingResponse {
+    return new PingResponse().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(
-    jsonString: string,
-    options?: Partial<JsonReadOptions>,
-  ): PingResponse {
-    return new PingResponse().fromJsonString(jsonString, options)
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PingResponse {
+    return new PingResponse().fromJsonString(jsonString, options);
   }
 
-  static equals(
-    a: PingResponse | PlainMessage<PingResponse> | undefined,
-    b: PingResponse | PlainMessage<PingResponse> | undefined,
-  ): boolean {
-    return proto3.util.equals(PingResponse, a, b)
+  static equals(a: PingResponse | PlainMessage<PingResponse> | undefined, b: PingResponse | PlainMessage<PingResponse> | undefined): boolean {
+    return proto3.util.equals(PingResponse, a, b);
   }
 }
+