@atproto/bsky 0.0.25 → 0.0.26

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

@@ -114,6 +114,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';
@@ -349,6 +350,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

@@ -7423,6 +7423,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;
@@ -7729,6 +7776,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/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;
+        };
+    };
+};

package/dist/proto/courier_pb.d.ts

@@ -0,0 +1,91 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from '@bufbuild/protobuf';
+import { Message, proto3, Struct, Timestamp } from '@bufbuild/protobuf';
+export declare enum AppPlatform {
+    UNSPECIFIED = 0,
+    IOS = 1,
+    ANDROID = 2,
+    WEB = 3
+}
+export declare class PingRequest extends Message<PingRequest> {
+    constructor(data?: PartialMessage<PingRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "courier.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 = "courier.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;
+}
+export declare class Notification extends Message<Notification> {
+    id: string;
+    recipientDid: string;
+    title: string;
+    message: string;
+    collapseKey: string;
+    alwaysDeliver: boolean;
+    timestamp?: Timestamp;
+    additional?: Struct;
+    constructor(data?: PartialMessage<Notification>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "courier.Notification";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Notification;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Notification;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Notification;
+    static equals(a: Notification | PlainMessage<Notification> | undefined, b: Notification | PlainMessage<Notification> | undefined): boolean;
+}
+export declare class PushNotificationsRequest extends Message<PushNotificationsRequest> {
+    notifications: Notification[];
+    constructor(data?: PartialMessage<PushNotificationsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "courier.PushNotificationsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PushNotificationsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PushNotificationsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PushNotificationsRequest;
+    static equals(a: PushNotificationsRequest | PlainMessage<PushNotificationsRequest> | undefined, b: PushNotificationsRequest | PlainMessage<PushNotificationsRequest> | undefined): boolean;
+}
+export declare class PushNotificationsResponse extends Message<PushNotificationsResponse> {
+    constructor(data?: PartialMessage<PushNotificationsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "courier.PushNotificationsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PushNotificationsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PushNotificationsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PushNotificationsResponse;
+    static equals(a: PushNotificationsResponse | PlainMessage<PushNotificationsResponse> | undefined, b: PushNotificationsResponse | PlainMessage<PushNotificationsResponse> | undefined): boolean;
+}
+export declare class RegisterDeviceTokenRequest extends Message<RegisterDeviceTokenRequest> {
+    did: string;
+    token: string;
+    appId: string;
+    platform: AppPlatform;
+    constructor(data?: PartialMessage<RegisterDeviceTokenRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "courier.RegisterDeviceTokenRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisterDeviceTokenRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisterDeviceTokenRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisterDeviceTokenRequest;
+    static equals(a: RegisterDeviceTokenRequest | PlainMessage<RegisterDeviceTokenRequest> | undefined, b: RegisterDeviceTokenRequest | PlainMessage<RegisterDeviceTokenRequest> | undefined): boolean;
+}
+export declare class RegisterDeviceTokenResponse extends Message<RegisterDeviceTokenResponse> {
+    constructor(data?: PartialMessage<RegisterDeviceTokenResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "courier.RegisterDeviceTokenResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisterDeviceTokenResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisterDeviceTokenResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisterDeviceTokenResponse;
+    static equals(a: RegisterDeviceTokenResponse | PlainMessage<RegisterDeviceTokenResponse> | undefined, b: RegisterDeviceTokenResponse | PlainMessage<RegisterDeviceTokenResponse> | undefined): boolean;
+}

package/dist/services/actor/index.d.ts

@@ -6,12 +6,11 @@ import { TimeCidKeyset } from '../../db/pagination';
 import { FromDb } from '../types';
 import { GraphService } from '../graph';
 import { LabelService } from '../label';
+import { Platform } from '../../notifications';
 export * from './types';
 export declare class ActorService {
     db: Database;
     imgUriBuilder: ImageUriBuilder;
-    private graph;
-    private label;
     views: ActorViews;
     constructor(db: Database, imgUriBuilder: ImageUriBuilder, graph: FromDb<GraphService>, label: FromDb<LabelService>);
     static creator(imgUriBuilder: ImageUriBuilder, graph: FromDb<GraphService>, label: FromDb<LabelService>): (db: Database) => ActorService;
@@ -40,6 +39,7 @@ export declare class ActorService {
         indexedAt: string;
         takedownRef: string | null;
     }, void, unknown>;
+    registerPushDeviceToken(did: string, token: string, platform: Platform, appId: string): Promise<void>;
 }
 type ActorResult = Actor;
 export declare class ListKeyset extends TimeCidKeyset<{

package/dist/services/indexing/index.d.ts

@@ -23,7 +23,7 @@ export declare class IndexingService {
     idResolver: IdResolver;
     autoMod: AutoModerator;
     backgroundQueue: BackgroundQueue;
-    notifServer?: NotificationServer | undefined;
+    notifServer?: NotificationServer<unknown> | undefined;
     records: {
         post: Post.PluginType;
         threadGate: Threadgate.PluginType;
@@ -37,7 +37,7 @@ export declare class IndexingService {
         block: Block.PluginType;
         feedGenerator: FeedGenerator.PluginType;
     };
-    constructor(db: PrimaryDatabase, idResolver: IdResolver, autoMod: AutoModerator, backgroundQueue: BackgroundQueue, notifServer?: NotificationServer | undefined);
+    constructor(db: PrimaryDatabase, idResolver: IdResolver, autoMod: AutoModerator, backgroundQueue: BackgroundQueue, notifServer?: NotificationServer<unknown> | undefined);
     transact(txn: PrimaryDatabase): IndexingService;
     static creator(idResolver: IdResolver, autoMod: AutoModerator, backgroundQueue: BackgroundQueue, notifServer?: NotificationServer): (db: PrimaryDatabase) => IndexingService;
     indexRecord(uri: AtUri, cid: CID, obj: unknown, action: WriteOpAction.Create | WriteOpAction.Update, timestamp: string, opts?: {