@atproto/bsky 0.0.25 → 0.0.27

package/dist/indexer/config.d.ts

@@ -19,6 +19,10 @@ export interface IndexerConfigValues {
     fuzzyFalsePositiveB64?: string;
     labelerKeywords: Record<string, string>;
     moderationPushUrl: string;
+    courierUrl?: string;
+    courierApiKey?: string;
+    courierHttpVersion?: '1.1' | '2';
+    courierIgnoreBadTls?: boolean;
     indexerConcurrency?: number;
     indexerPartitionIds: number[];
     indexerPartitionBatchSize?: number;
@@ -45,6 +49,10 @@ export declare class IndexerConfig {
     get didCacheMaxTTL(): number;
     get handleResolveNameservers(): string[] | undefined;
     get moderationPushUrl(): string;
+    get courierUrl(): string | undefined;
+    get courierApiKey(): string | undefined;
+    get courierHttpVersion(): "2" | "1.1" | undefined;
+    get courierIgnoreBadTls(): boolean | undefined;
     get hiveApiKey(): string | undefined;
     get abyssEndpoint(): string | undefined;
     get abyssPassword(): string | undefined;

package/dist/indexer/context.d.ts

@@ -6,6 +6,7 @@ import { BackgroundQueue } from '../background';
 import DidSqlCache from '../did-cache';
 import { Redis } from '../redis';
 import { AutoModerator } from '../auto-moderator';
+import { NotificationServer } from '../notifications';
 export declare class IndexerContext {
     private opts;
     constructor(opts: {
@@ -18,6 +19,7 @@ export declare class IndexerContext {
         didCache: DidSqlCache;
         backgroundQueue: BackgroundQueue;
         autoMod: AutoModerator;
+        notifServer?: NotificationServer;
     });
     get db(): PrimaryDatabase;
     get redis(): Redis;
@@ -28,5 +30,6 @@ export declare class IndexerContext {
     get didCache(): DidSqlCache;
     get backgroundQueue(): BackgroundQueue;
     get autoMod(): AutoModerator;
+    get notifServer(): NotificationServer | undefined;
 }
 export default IndexerContext;

package/dist/ingester/config.d.ts

@@ -8,6 +8,10 @@ export interface IngesterConfigValues {
     redisPassword?: string;
     repoProvider: string;
     labelProvider?: string;
+    bsyncUrl?: string;
+    bsyncApiKey?: string;
+    bsyncHttpVersion?: '1.1' | '2';
+    bsyncIgnoreBadTls?: boolean;
     ingesterPartitionCount: number;
     ingesterNamespace?: string;
     ingesterSubLockId?: number;
@@ -28,6 +32,10 @@ export declare class IngesterConfig {
     get redisPassword(): string | undefined;
     get repoProvider(): string;
     get labelProvider(): string | undefined;
+    get bsyncUrl(): string | undefined;
+    get bsyncApiKey(): string | undefined;
+    get bsyncHttpVersion(): "2" | "1.1" | undefined;
+    get bsyncIgnoreBadTls(): boolean | undefined;
     get ingesterPartitionCount(): number;
     get ingesterMaxItems(): number | undefined;
     get ingesterCheckItemsEveryN(): number | undefined;

package/dist/ingester/context.d.ts

@@ -2,6 +2,7 @@ import { PrimaryDatabase } from '../db';
 import { Redis } from '../redis';
 import { IngesterConfig } from './config';
 import { LabelSubscription } from './label-subscription';
+import { MuteSubscription } from './mute-subscription';
 export declare class IngesterContext {
     private opts;
     constructor(opts: {
@@ -9,10 +10,12 @@ export declare class IngesterContext {
         redis: Redis;
         cfg: IngesterConfig;
         labelSubscription?: LabelSubscription;
+        muteSubscription?: MuteSubscription;
     });
     get db(): PrimaryDatabase;
     get redis(): Redis;
     get cfg(): IngesterConfig;
     get labelSubscription(): LabelSubscription | undefined;
+    get muteSubscription(): MuteSubscription | undefined;
 }
 export default IngesterContext;

package/dist/ingester/mute-subscription.d.ts

@@ -0,0 +1,22 @@
+import { PrimaryDatabase } from '../db';
+import { Redis } from '../redis';
+import { BsyncClient } from '../bsync';
+import { MuteOperation } from '../proto/bsync_pb';
+export declare class MuteSubscription {
+    db: PrimaryDatabase;
+    redis: Redis;
+    bsyncClient: BsyncClient;
+    ac: AbortController;
+    running: Promise<void> | undefined;
+    cursor: string | null;
+    constructor(db: PrimaryDatabase, redis: Redis, bsyncClient: BsyncClient);
+    start(): Promise<void>;
+    private run;
+    handleAddOp(op: MuteOperation, createdAt: Date): Promise<void>;
+    handleRemoveOp(op: MuteOperation): Promise<void>;
+    handleClearOp(op: MuteOperation): Promise<void>;
+    getCursor(): Promise<string | null>;
+    setCursor(cursor: string): Promise<void>;
+    destroy(): Promise<void>;
+    get destroyed(): boolean;
+}

package/dist/lexicon/index.d.ts

@@ -104,6 +104,7 @@ import * as AppBskyGraphGetListBlocks from './types/app/bsky/graph/getListBlocks
 import * as AppBskyGraphGetListMutes from './types/app/bsky/graph/getListMutes';
 import * as AppBskyGraphGetLists from './types/app/bsky/graph/getLists';
 import * as AppBskyGraphGetMutes from './types/app/bsky/graph/getMutes';
+import * as AppBskyGraphGetRelationships from './types/app/bsky/graph/getRelationships';
 import * as AppBskyGraphGetSuggestedFollowsByActor from './types/app/bsky/graph/getSuggestedFollowsByActor';
 import * as AppBskyGraphMuteActor from './types/app/bsky/graph/muteActor';
 import * as AppBskyGraphMuteActorList from './types/app/bsky/graph/muteActorList';
@@ -114,6 +115,7 @@ import * as AppBskyNotificationListNotifications from './types/app/bsky/notifica
 import * as AppBskyNotificationRegisterPush from './types/app/bsky/notification/registerPush';
 import * as AppBskyNotificationUpdateSeen from './types/app/bsky/notification/updateSeen';
 import * as AppBskyUnspeccedGetPopularFeedGenerators from './types/app/bsky/unspecced/getPopularFeedGenerators';
+import * as AppBskyUnspeccedGetTaggedSuggestions from './types/app/bsky/unspecced/getTaggedSuggestions';
 import * as AppBskyUnspeccedGetTimelineSkeleton from './types/app/bsky/unspecced/getTimelineSkeleton';
 import * as AppBskyUnspeccedSearchActorsSkeleton from './types/app/bsky/unspecced/searchActorsSkeleton';
 import * as AppBskyUnspeccedSearchPostsSkeleton from './types/app/bsky/unspecced/searchPostsSkeleton';
@@ -327,6 +329,7 @@ export declare class AppBskyGraphNS {
     getListMutes<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyGraphGetListMutes.Handler<ExtractAuth<AV>>, AppBskyGraphGetListMutes.HandlerReqCtx<ExtractAuth<AV>>>): void;
     getLists<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyGraphGetLists.Handler<ExtractAuth<AV>>, AppBskyGraphGetLists.HandlerReqCtx<ExtractAuth<AV>>>): void;
     getMutes<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyGraphGetMutes.Handler<ExtractAuth<AV>>, AppBskyGraphGetMutes.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getRelationships<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyGraphGetRelationships.Handler<ExtractAuth<AV>>, AppBskyGraphGetRelationships.HandlerReqCtx<ExtractAuth<AV>>>): void;
     getSuggestedFollowsByActor<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyGraphGetSuggestedFollowsByActor.Handler<ExtractAuth<AV>>, AppBskyGraphGetSuggestedFollowsByActor.HandlerReqCtx<ExtractAuth<AV>>>): void;
     muteActor<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyGraphMuteActor.Handler<ExtractAuth<AV>>, AppBskyGraphMuteActor.HandlerReqCtx<ExtractAuth<AV>>>): void;
     muteActorList<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyGraphMuteActorList.Handler<ExtractAuth<AV>>, AppBskyGraphMuteActorList.HandlerReqCtx<ExtractAuth<AV>>>): void;
@@ -349,6 +352,7 @@ export declare class AppBskyUnspeccedNS {
     _server: Server;
     constructor(server: Server);
     getPopularFeedGenerators<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyUnspeccedGetPopularFeedGenerators.Handler<ExtractAuth<AV>>, AppBskyUnspeccedGetPopularFeedGenerators.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getTaggedSuggestions<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyUnspeccedGetTaggedSuggestions.Handler<ExtractAuth<AV>>, AppBskyUnspeccedGetTaggedSuggestions.HandlerReqCtx<ExtractAuth<AV>>>): void;
     getTimelineSkeleton<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyUnspeccedGetTimelineSkeleton.Handler<ExtractAuth<AV>>, AppBskyUnspeccedGetTimelineSkeleton.HandlerReqCtx<ExtractAuth<AV>>>): void;
     searchActorsSkeleton<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyUnspeccedSearchActorsSkeleton.Handler<ExtractAuth<AV>>, AppBskyUnspeccedSearchActorsSkeleton.HandlerReqCtx<ExtractAuth<AV>>>): void;
     searchPostsSkeleton<AV extends AuthVerifier>(cfg: ConfigOf<AV, AppBskyUnspeccedSearchPostsSkeleton.Handler<ExtractAuth<AV>>, AppBskyUnspeccedSearchPostsSkeleton.HandlerReqCtx<ExtractAuth<AV>>>): void;

package/dist/lexicon/lexicons.d.ts

@@ -4344,6 +4344,22 @@ export declare const schemaDict: {
                     };
                 };
             };
+            interestsPref: {
+                type: string;
+                required: string[];
+                properties: {
+                    tags: {
+                        type: string;
+                        maxLength: number;
+                        items: {
+                            type: string;
+                            maxLength: number;
+                            maxGraphemes: number;
+                        };
+                        description: string;
+                    };
+                };
+            };
         };
     };
     AppBskyActorGetPreferences: {
@@ -6461,6 +6477,42 @@ export declare const schemaDict: {
                     };
                 };
             };
+            notFoundActor: {
+                type: string;
+                description: string;
+                required: string[];
+                properties: {
+                    actor: {
+                        type: string;
+                        format: string;
+                    };
+                    notFound: {
+                        type: string;
+                        const: boolean;
+                    };
+                };
+            };
+            relationship: {
+                type: string;
+                description: string;
+                required: string[];
+                properties: {
+                    did: {
+                        type: string;
+                        format: string;
+                    };
+                    following: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                    followedBy: {
+                        type: string;
+                        format: string;
+                        description: string;
+                    };
+                };
+            };
         };
     };
     AppBskyGraphFollow: {
@@ -6864,6 +6916,58 @@ export declare const schemaDict: {
             };
         };
     };
+    AppBskyGraphGetRelationships: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                parameters: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        actor: {
+                            type: string;
+                            format: string;
+                        };
+                        others: {
+                            type: string;
+                            maxLength: number;
+                            items: {
+                                type: string;
+                                format: string;
+                            };
+                        };
+                    };
+                };
+                output: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            actor: {
+                                type: string;
+                                format: string;
+                            };
+                            relationships: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                    refs: string[];
+                                };
+                            };
+                        };
+                    };
+                };
+                errors: {
+                    name: string;
+                    description: string;
+                }[];
+            };
+        };
+    };
     AppBskyGraphGetSuggestedFollowsByActor: {
         lexicon: number;
         id: string;
@@ -7423,6 +7527,53 @@ export declare const schemaDict: {
             };
         };
     };
+    AppBskyUnspeccedGetTaggedSuggestions: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                parameters: {
+                    type: string;
+                    properties: {};
+                };
+                output: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            suggestions: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                    ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            suggestion: {
+                type: string;
+                required: string[];
+                properties: {
+                    tag: {
+                        type: string;
+                    };
+                    subjectType: {
+                        type: string;
+                        knownValues: string[];
+                    };
+                    subject: {
+                        type: string;
+                        format: string;
+                    };
+                };
+            };
+        };
+    };
     AppBskyUnspeccedGetTimelineSkeleton: {
         lexicon: number;
         id: string;
@@ -7714,6 +7865,7 @@ export declare const ids: {
     AppBskyGraphGetListMutes: string;
     AppBskyGraphGetLists: string;
     AppBskyGraphGetMutes: string;
+    AppBskyGraphGetRelationships: string;
     AppBskyGraphGetSuggestedFollowsByActor: string;
     AppBskyGraphList: string;
     AppBskyGraphListblock: string;
@@ -7729,6 +7881,7 @@ export declare const ids: {
     AppBskyRichtextFacet: string;
     AppBskyUnspeccedDefs: string;
     AppBskyUnspeccedGetPopularFeedGenerators: string;
+    AppBskyUnspeccedGetTaggedSuggestions: string;
     AppBskyUnspeccedGetTimelineSkeleton: string;
     AppBskyUnspeccedSearchActorsSkeleton: string;
     AppBskyUnspeccedSearchPostsSkeleton: string;

package/dist/lexicon/types/app/bsky/actor/defs.d.ts

@@ -54,7 +54,7 @@ export interface ViewerState {
 }
 export declare function isViewerState(v: unknown): v is ViewerState;
 export declare function validateViewerState(v: unknown): ValidationResult;
-export type Preferences = (AdultContentPref | ContentLabelPref | SavedFeedsPref | PersonalDetailsPref | FeedViewPref | ThreadViewPref | {
+export type Preferences = (AdultContentPref | ContentLabelPref | SavedFeedsPref | PersonalDetailsPref | FeedViewPref | ThreadViewPref | InterestsPref | {
     $type: string;
     [k: string]: unknown;
 })[];
@@ -102,3 +102,9 @@ export interface ThreadViewPref {
 }
 export declare function isThreadViewPref(v: unknown): v is ThreadViewPref;
 export declare function validateThreadViewPref(v: unknown): ValidationResult;
+export interface InterestsPref {
+    tags: string[];
+    [k: string]: unknown;
+}
+export declare function isInterestsPref(v: unknown): v is InterestsPref;
+export declare function validateInterestsPref(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/graph/defs.d.ts

@@ -45,3 +45,18 @@ export interface ListViewerState {
 }
 export declare function isListViewerState(v: unknown): v is ListViewerState;
 export declare function validateListViewerState(v: unknown): ValidationResult;
+export interface NotFoundActor {
+    actor: string;
+    notFound: true;
+    [k: string]: unknown;
+}
+export declare function isNotFoundActor(v: unknown): v is NotFoundActor;
+export declare function validateNotFoundActor(v: unknown): ValidationResult;
+export interface Relationship {
+    did: string;
+    following?: string;
+    followedBy?: string;
+    [k: string]: unknown;
+}
+export declare function isRelationship(v: unknown): v is Relationship;
+export declare function validateRelationship(v: unknown): ValidationResult;

package/dist/lexicon/types/app/bsky/graph/getRelationships.d.ts

@@ -0,0 +1,38 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as AppBskyGraphDefs from './defs';
+export interface QueryParams {
+    actor: string;
+    others?: string[];
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    actor?: string;
+    relationships: (AppBskyGraphDefs.Relationship | AppBskyGraphDefs.NotFoundActor | {
+        $type: string;
+        [k: string]: unknown;
+    })[];
+    [k: string]: unknown;
+}
+export type HandlerInput = undefined;
+export interface HandlerSuccess {
+    encoding: 'application/json';
+    body: OutputSchema;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+    error?: 'ActorNotFound';
+}
+export type HandlerOutput = HandlerError | HandlerSuccess;
+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/dist/lexicon/types/app/bsky/unspecced/getTaggedSuggestions.d.ts

@@ -0,0 +1,39 @@
+import express from 'express';
+import { ValidationResult } from '@atproto/lexicon';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    suggestions: Suggestion[];
+    [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;
+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 Suggestion {
+    tag: string;
+    subjectType: 'actor' | 'feed' | (string & {});
+    subject: string;
+    [k: string]: unknown;
+}
+export declare function isSuggestion(v: unknown): v is Suggestion;
+export declare function validateSuggestion(v: unknown): ValidationResult;

package/dist/notifications.d.ts

@@ -2,8 +2,10 @@ import { Insertable } from 'kysely';
 import Database from './db/primary';
 import { Notification } from './db/tables/notification';
 import { NotificationPushToken as PushToken } from './db/tables/notification-push-token';
+import { Notification as CourierNotification } from './proto/courier_pb';
+import { CourierClient } from './courier';
 export type Platform = 'ios' | 'android' | 'web';
-type PushNotification = {
+type GorushNotification = {
     tokens: string[];
     platform: 1 | 2;
     title: string;
@@ -15,28 +17,37 @@ type PushNotification = {
     collapse_id?: string;
     collapse_key?: string;
 };
-type InsertableNotif = Insertable<Notification>;
-type NotifDisplay = {
+type NotifRow = Insertable<Notification>;
+type NotifView = {
     key: string;
     rateLimit: boolean;
     title: string;
     body: string;
-    notif: InsertableNotif;
+    notif: NotifRow;
 };
-export declare class NotificationServer {
+export declare abstract class NotificationServer<N = unknown> {
     db: Database;
-    pushEndpoint?: string | undefined;
+    constructor(db: Database);
+    abstract prepareNotifications(notifs: NotifRow[]): Promise<N[]>;
+    abstract processNotifications(prepared: N[]): Promise<void>;
+    getNotificationViews(notifs: NotifRow[]): Promise<NotifView[]>;
+    private findBlocksAndMutes;
+}
+export declare class GorushNotificationServer extends NotificationServer<GorushNotification> {
+    db: Database;
+    pushEndpoint: string;
     private rateLimiter;
-    constructor(db: Database, pushEndpoint?: string | undefined);
+    constructor(db: Database, pushEndpoint: string);
+    prepareNotifications(notifs: NotifRow[]): Promise<GorushNotification[]>;
     getTokensByDid(dids: string[]): Promise<Record<string, PushToken[]>>;
-    prepareNotifsToSend(notifications: InsertableNotif[]): Promise<PushNotification[]>;
-    processNotifications(notifs: PushNotification[]): Promise<void>;
-    private sendPushNotifications;
-    registerDeviceForPushNotifications(did: string, token: string, platform: Platform, appId: string): Promise<void>;
-    getNotificationDisplayAttributes(notifs: InsertableNotif[]): Promise<NotifDisplay[]>;
-    findBlocksAndMutes(notifs: InsertableNotif[]): Promise<{
-        author: string;
-        receiver: string;
-    }[]>;
+    processNotifications(prepared: GorushNotification[]): Promise<void>;
+    private sendToGorush;
+}
+export declare class CourierNotificationServer extends NotificationServer<CourierNotification> {
+    db: Database;
+    courierClient: CourierClient;
+    constructor(db: Database, courierClient: CourierClient);
+    prepareNotifications(notifs: NotifRow[]): Promise<CourierNotification[]>;
+    processNotifications(prepared: CourierNotification[]): Promise<void>;
 }
 export {};

package/dist/proto/bsync_connect.d.ts

@@ -0,0 +1,25 @@
+import { AddMuteOperationRequest, AddMuteOperationResponse, PingRequest, PingResponse, ScanMuteOperationsRequest, ScanMuteOperationsResponse } from './bsync_pb.ts';
+import { MethodKind } from '@bufbuild/protobuf';
+export declare const Service: {
+    readonly typeName: "bsync.Service";
+    readonly methods: {
+        readonly addMuteOperation: {
+            readonly name: "AddMuteOperation";
+            readonly I: typeof AddMuteOperationRequest;
+            readonly O: typeof AddMuteOperationResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        readonly scanMuteOperations: {
+            readonly name: "ScanMuteOperations";
+            readonly I: typeof ScanMuteOperationsRequest;
+            readonly O: typeof ScanMuteOperationsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        readonly ping: {
+            readonly name: "Ping";
+            readonly I: typeof PingRequest;
+            readonly O: typeof PingResponse;
+            readonly kind: MethodKind.Unary;
+        };
+    };
+};

package/dist/proto/bsync_pb.d.ts

@@ -0,0 +1,90 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from '@bufbuild/protobuf';
+import { Message, proto3 } from '@bufbuild/protobuf';
+export declare class MuteOperation extends Message<MuteOperation> {
+    id: string;
+    type: MuteOperation_Type;
+    actorDid: string;
+    subject: string;
+    constructor(data?: PartialMessage<MuteOperation>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.MuteOperation";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MuteOperation;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MuteOperation;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MuteOperation;
+    static equals(a: MuteOperation | PlainMessage<MuteOperation> | undefined, b: MuteOperation | PlainMessage<MuteOperation> | undefined): boolean;
+}
+export declare enum MuteOperation_Type {
+    UNSPECIFIED = 0,
+    ADD = 1,
+    REMOVE = 2,
+    CLEAR = 3
+}
+export declare class AddMuteOperationRequest extends Message<AddMuteOperationRequest> {
+    type: MuteOperation_Type;
+    actorDid: string;
+    subject: string;
+    constructor(data?: PartialMessage<AddMuteOperationRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.AddMuteOperationRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddMuteOperationRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddMuteOperationRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddMuteOperationRequest;
+    static equals(a: AddMuteOperationRequest | PlainMessage<AddMuteOperationRequest> | undefined, b: AddMuteOperationRequest | PlainMessage<AddMuteOperationRequest> | undefined): boolean;
+}
+export declare class AddMuteOperationResponse extends Message<AddMuteOperationResponse> {
+    operation?: MuteOperation;
+    constructor(data?: PartialMessage<AddMuteOperationResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.AddMuteOperationResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddMuteOperationResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddMuteOperationResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddMuteOperationResponse;
+    static equals(a: AddMuteOperationResponse | PlainMessage<AddMuteOperationResponse> | undefined, b: AddMuteOperationResponse | PlainMessage<AddMuteOperationResponse> | undefined): boolean;
+}
+export declare class ScanMuteOperationsRequest extends Message<ScanMuteOperationsRequest> {
+    cursor: string;
+    limit: number;
+    constructor(data?: PartialMessage<ScanMuteOperationsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.ScanMuteOperationsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ScanMuteOperationsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanMuteOperationsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanMuteOperationsRequest;
+    static equals(a: ScanMuteOperationsRequest | PlainMessage<ScanMuteOperationsRequest> | undefined, b: ScanMuteOperationsRequest | PlainMessage<ScanMuteOperationsRequest> | undefined): boolean;
+}
+export declare class ScanMuteOperationsResponse extends Message<ScanMuteOperationsResponse> {
+    operations: MuteOperation[];
+    cursor: string;
+    constructor(data?: PartialMessage<ScanMuteOperationsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.ScanMuteOperationsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ScanMuteOperationsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ScanMuteOperationsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ScanMuteOperationsResponse;
+    static equals(a: ScanMuteOperationsResponse | PlainMessage<ScanMuteOperationsResponse> | undefined, b: ScanMuteOperationsResponse | PlainMessage<ScanMuteOperationsResponse> | undefined): boolean;
+}
+export declare class PingRequest extends Message<PingRequest> {
+    constructor(data?: PartialMessage<PingRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.PingRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PingRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PingRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PingRequest;
+    static equals(a: PingRequest | PlainMessage<PingRequest> | undefined, b: PingRequest | PlainMessage<PingRequest> | undefined): boolean;
+}
+export declare class PingResponse extends Message<PingResponse> {
+    constructor(data?: PartialMessage<PingResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "bsync.PingResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PingResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PingResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PingResponse;
+    static equals(a: PingResponse | PlainMessage<PingResponse> | undefined, b: PingResponse | PlainMessage<PingResponse> | undefined): boolean;
+}

package/dist/proto/courier_connect.d.ts

@@ -0,0 +1,25 @@
+import { PingRequest, PingResponse, PushNotificationsRequest, PushNotificationsResponse, RegisterDeviceTokenRequest, RegisterDeviceTokenResponse } from './courier_pb.ts';
+import { MethodKind } from '@bufbuild/protobuf';
+export declare const Service: {
+    readonly typeName: "courier.Service";
+    readonly methods: {
+        readonly ping: {
+            readonly name: "Ping";
+            readonly I: typeof PingRequest;
+            readonly O: typeof PingResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        readonly pushNotifications: {
+            readonly name: "PushNotifications";
+            readonly I: typeof PushNotificationsRequest;
+            readonly O: typeof PushNotificationsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        readonly registerDeviceToken: {
+            readonly name: "RegisterDeviceToken";
+            readonly I: typeof RegisterDeviceTokenRequest;
+            readonly O: typeof RegisterDeviceTokenResponse;
+            readonly kind: MethodKind.Unary;
+        };
+    };
+};