@atproto/bsky 0.0.16 → 0.0.17

package/dist/indexer/context.d.ts

@@ -11,6 +11,7 @@ export declare class IndexerContext {
     constructor(opts: {
         db: PrimaryDatabase;
         redis: Redis;
+        redisCache: Redis;
         cfg: IndexerConfig;
         services: Services;
         idResolver: IdResolver;
@@ -20,6 +21,7 @@ export declare class IndexerContext {
     });
     get db(): PrimaryDatabase;
     get redis(): Redis;
+    get redisCache(): Redis;
     get cfg(): IndexerConfig;
     get services(): Services;
     get idResolver(): IdResolver;

package/dist/indexer/index.d.ts

@@ -22,6 +22,7 @@ export declare class BskyIndexer {
     static create(opts: {
         db: PrimaryDatabase;
         redis: Redis;
+        redisCache: Redis;
         cfg: IndexerConfig;
         imgInvalidator?: ImageInvalidator;
     }): BskyIndexer;

package/dist/lexicon/index.d.ts

@@ -1,4 +1,5 @@
 import { Server as XrpcServer, Options as XrpcOptions, AuthVerifier, StreamAuthVerifier } from '@atproto/xrpc-server';
+import * as ComAtprotoAdminDeleteAccount from './types/com/atproto/admin/deleteAccount';
 import * as ComAtprotoAdminDisableAccountInvites from './types/com/atproto/admin/disableAccountInvites';
 import * as ComAtprotoAdminDisableInviteCodes from './types/com/atproto/admin/disableInviteCodes';
 import * as ComAtprotoAdminEmitModerationEvent from './types/com/atproto/admin/emitModerationEvent';
@@ -63,6 +64,9 @@ import * as ComAtprotoSyncNotifyOfUpdate from './types/com/atproto/sync/notifyOf
 import * as ComAtprotoSyncRequestCrawl from './types/com/atproto/sync/requestCrawl';
 import * as ComAtprotoSyncSubscribeRepos from './types/com/atproto/sync/subscribeRepos';
 import * as ComAtprotoTempFetchLabels from './types/com/atproto/temp/fetchLabels';
+import * as ComAtprotoTempImportRepo from './types/com/atproto/temp/importRepo';
+import * as ComAtprotoTempPushBlob from './types/com/atproto/temp/pushBlob';
+import * as ComAtprotoTempTransferAccount from './types/com/atproto/temp/transferAccount';
 import * as AppBskyActorGetPreferences from './types/app/bsky/actor/getPreferences';
 import * as AppBskyActorGetProfile from './types/app/bsky/actor/getProfile';
 import * as AppBskyActorGetProfiles from './types/app/bsky/actor/getProfiles';
@@ -152,6 +156,7 @@ export declare class AtprotoNS {
 export declare class AdminNS {
     _server: Server;
     constructor(server: Server);
+    deleteAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminDeleteAccount.Handler<ExtractAuth<AV>>, ComAtprotoAdminDeleteAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
     disableAccountInvites<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminDisableAccountInvites.Handler<ExtractAuth<AV>>, ComAtprotoAdminDisableAccountInvites.HandlerReqCtx<ExtractAuth<AV>>>): void;
     disableInviteCodes<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminDisableInviteCodes.Handler<ExtractAuth<AV>>, ComAtprotoAdminDisableInviteCodes.HandlerReqCtx<ExtractAuth<AV>>>): void;
     emitModerationEvent<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminEmitModerationEvent.Handler<ExtractAuth<AV>>, ComAtprotoAdminEmitModerationEvent.HandlerReqCtx<ExtractAuth<AV>>>): void;
@@ -244,6 +249,9 @@ export declare class TempNS {
     _server: Server;
     constructor(server: Server);
     fetchLabels<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempFetchLabels.Handler<ExtractAuth<AV>>, ComAtprotoTempFetchLabels.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    importRepo<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempImportRepo.Handler<ExtractAuth<AV>>, ComAtprotoTempImportRepo.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    pushBlob<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempPushBlob.Handler<ExtractAuth<AV>>, ComAtprotoTempPushBlob.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    transferAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempTransferAccount.Handler<ExtractAuth<AV>>, ComAtprotoTempTransferAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
 }
 export declare class AppNS {
     _server: Server;
@@ -345,9 +353,13 @@ declare type RouteRateLimitOpts<T> = {
     calcKey?: (ctx: T) => string;
     calcPoints?: (ctx: T) => number;
 };
+declare type HandlerOpts = {
+    blobLimit?: number;
+};
 declare type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>;
 declare type ConfigOf<Auth, Handler, ReqCtx> = Handler | {
     auth?: Auth;
+    opts?: HandlerOpts;
     rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[];
     handler: Handler;
 };

package/dist/lexicon/lexicons.d.ts

@@ -709,6 +709,29 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoAdminDeleteAccount: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            did: {
+                                type: string;
+                                format: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
     ComAtprotoAdminDisableAccountInvites: {
         lexicon: number;
         id: string;
@@ -3656,6 +3679,113 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoTempImportRepo: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                parameters: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        did: {
+                            type: string;
+                            format: string;
+                            description: string;
+                        };
+                    };
+                };
+                input: {
+                    encoding: string;
+                };
+                output: {
+                    encoding: string;
+                };
+            };
+        };
+    };
+    ComAtprotoTempPushBlob: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                parameters: {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        did: {
+                            type: string;
+                            format: string;
+                            description: string;
+                        };
+                    };
+                };
+                input: {
+                    encoding: string;
+                };
+            };
+        };
+    };
+    ComAtprotoTempTransferAccount: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            handle: {
+                                type: string;
+                                format: string;
+                            };
+                            did: {
+                                type: string;
+                                format: string;
+                            };
+                            plcOp: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+                output: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            accessJwt: {
+                                type: string;
+                            };
+                            refreshJwt: {
+                                type: string;
+                            };
+                            handle: {
+                                type: string;
+                                format: string;
+                            };
+                            did: {
+                                type: string;
+                                format: string;
+                            };
+                        };
+                    };
+                };
+                errors: {
+                    name: string;
+                }[];
+            };
+        };
+    };
     AppBskyActorDefs: {
         lexicon: number;
         id: string;
@@ -7214,6 +7344,7 @@ export declare const schemas: LexiconDoc[];
 export declare const lexicons: Lexicons;
 export declare const ids: {
     ComAtprotoAdminDefs: string;
+    ComAtprotoAdminDeleteAccount: string;
     ComAtprotoAdminDisableAccountInvites: string;
     ComAtprotoAdminDisableInviteCodes: string;
     ComAtprotoAdminEmitModerationEvent: string;
@@ -7282,6 +7413,9 @@ export declare const ids: {
     ComAtprotoSyncRequestCrawl: string;
     ComAtprotoSyncSubscribeRepos: string;
     ComAtprotoTempFetchLabels: string;
+    ComAtprotoTempImportRepo: string;
+    ComAtprotoTempPushBlob: string;
+    ComAtprotoTempTransferAccount: string;
     AppBskyActorDefs: string;
     AppBskyActorGetPreferences: string;
     AppBskyActorGetProfile: string;

package/dist/lexicon/types/com/atproto/admin/deleteAccount.d.ts

@@ -0,0 +1,25 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    did: string;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export declare type HandlerOutput = HandlerError | void;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/com/atproto/temp/importRepo.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import express from 'express';
+import stream from 'stream';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+    did: string;
+}
+export declare type InputSchema = string | Uint8Array;
+export interface HandlerInput {
+    encoding: 'application/vnd.ipld.car';
+    body: stream.Readable;
+}
+export interface HandlerSuccess {
+    encoding: 'text/plain';
+    body: Uint8Array | stream.Readable;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export declare type HandlerOutput = HandlerError | HandlerSuccess;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/com/atproto/temp/pushBlob.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import express from 'express';
+import stream from 'stream';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+    did: string;
+}
+export declare type InputSchema = string | Uint8Array;
+export interface HandlerInput {
+    encoding: '*/*';
+    body: stream.Readable;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export declare type HandlerOutput = HandlerError | void;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/com/atproto/temp/transferAccount.d.ts

@@ -0,0 +1,42 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    handle: string;
+    did: string;
+    plcOp: {};
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    accessJwt: string;
+    refreshJwt: string;
+    handle: string;
+    did: string;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerSuccess {
+    encoding: 'application/json';
+    body: OutputSchema;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+    error?: 'InvalidHandle' | 'InvalidPassword' | 'InvalidInviteCode' | 'HandleNotAvailable' | 'UnsupportedDomain' | 'UnresolvableDid' | 'IncompatibleDidDoc';
+}
+export declare type HandlerOutput = HandlerError | HandlerSuccess;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/logger.d.ts

@@ -1,5 +1,6 @@
 import { subsystemLogger } from '@atproto/common';
 export declare const dbLogger: ReturnType<typeof subsystemLogger>;
+export declare const cacheLogger: ReturnType<typeof subsystemLogger>;
 export declare const subLogger: ReturnType<typeof subsystemLogger>;
 export declare const labelerLogger: ReturnType<typeof subsystemLogger>;
 export declare const httpLogger: ReturnType<typeof subsystemLogger>;

package/dist/redis.d.ts

@@ -4,6 +4,7 @@ export declare class Redis {
     driver: RedisDriver;
     namespace?: string;
     constructor(opts: RedisOptions);
+    withNamespace(namespace: string): Redis;
     readStreams(streams: StreamRef[], opts: {
         count: number;
         blockMs?: number;
@@ -17,7 +18,9 @@ export declare class Redis {
     trimStream(key: string, cursor: number | string): Promise<void>;
     streamLengths(keys: string[]): Promise<number[]>;
     get(key: string): Promise<string | null>;
-    set(key: string, val: string | number): Promise<void>;
+    set(key: string, val: string | number, ttlMs?: number): Promise<void>;
+    getMulti(keys: string[]): Promise<{}>;
+    setMulti(vals: Record<string, string | number>, ttlMs?: number): Promise<void>;
     del(key: string): Promise<number>;
     expire(key: string, seconds: number): Promise<number>;
     zremrangebyscore(key: string, min: number, max: number): Promise<number>;
@@ -48,5 +51,11 @@ export declare type RedisOptions = ({
 }) & {
     password?: string;
     namespace?: string;
+    db?: number;
+    commandTimeout?: number;
+};
+export declare function addressParts(addr: string, defaultPort?: number): {
+    host: string;
+    port: number;
 };
 export {};

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

@@ -2,16 +2,19 @@ import { Database } from '../../db';
 import { ActorViews } from './views';
 import { ImageUriBuilder } from '../../image/uri';
 import { Actor } from '../../db/tables/actor';
-import { LabelCache } from '../../label-cache';
 import { TimeCidKeyset } from '../../db/pagination';
+import { FromDb } from '../types';
+import { GraphService } from '../graph';
+import { LabelService } from '../label';
 export * from './types';
 export declare class ActorService {
     db: Database;
     imgUriBuilder: ImageUriBuilder;
-    labelCache: LabelCache;
-    constructor(db: Database, imgUriBuilder: ImageUriBuilder, labelCache: LabelCache);
-    static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache): (db: Database) => ActorService;
+    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;
     getActorDid(handleOrDid: string): Promise<string | null>;
     getActor(handleOrDid: string, includeSoftDeleted?: boolean): Promise<ActorResult | null>;
     getActors(handleOrDids: string[], includeSoftDeleted?: boolean): Promise<ActorResult[]>;
@@ -25,6 +28,17 @@ export declare class ActorService {
         cursor: any;
     }>;
     getRepoRev(did: string | null): Promise<string | null>;
+    all(opts?: {
+        batchSize?: number;
+        forever?: boolean;
+        cooldownMs?: number;
+        startFromDid?: string;
+    }): AsyncGenerator<{
+        did: string;
+        handle: string | null;
+        indexedAt: string;
+        takedownId: number | null;
+    }, void, unknown>;
 }
 declare type ActorResult = Actor;
 export declare class ListKeyset extends TimeCidKeyset<{

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

@@ -4,18 +4,19 @@ import { Actor } from '../../db/tables/actor';
 import { ImageUriBuilder } from '../../image/uri';
 import { LabelService, Labels } from '../label';
 import { BlockAndMuteState, GraphService } from '../graph';
-import { LabelCache } from '../../label-cache';
 import { ActorInfoMap, ProfileDetailHydrationState, ProfileHydrationState, ProfileInfoMap, ProfileViewMap } from './types';
 import { ListInfoMap } from '../graph/types';
+import { FromDb } from '../types';
 export declare class ActorViews {
     private db;
     private imgUriBuilder;
-    private labelCache;
-    constructor(db: Database, imgUriBuilder: ImageUriBuilder, labelCache: LabelCache);
+    private graph;
+    private label;
     services: {
         label: LabelService;
         graph: GraphService;
     };
+    constructor(db: Database, imgUriBuilder: ImageUriBuilder, graph: FromDb<GraphService>, label: FromDb<LabelService>);
     profiles(results: (ActorResult | string)[], viewer: string | null, opts?: {
         includeSoftDeleted?: boolean;
     }): Promise<ActorInfoMap>;

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

@@ -6,20 +6,22 @@ import { LabelService } from '../label';
 import { ActorService } from '../actor';
 import { BlockAndMuteState, GraphService, ListInfoMap } from '../graph';
 import { FeedViews } from './views';
-import { LabelCache } from '../../label-cache';
+import { FromDb } from '../types';
 export * from './types';
 export declare class FeedService {
     db: Database;
     imgUriBuilder: ImageUriBuilder;
-    labelCache: LabelCache;
-    constructor(db: Database, imgUriBuilder: ImageUriBuilder, labelCache: LabelCache);
+    private actor;
+    private label;
+    private graph;
     views: FeedViews;
     services: {
         label: LabelService;
         actor: ActorService;
         graph: GraphService;
     };
-    static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache): (db: Database) => FeedService;
+    constructor(db: Database, imgUriBuilder: ImageUriBuilder, actor: FromDb<ActorService>, label: FromDb<LabelService>, graph: FromDb<GraphService>);
+    static creator(imgUriBuilder: ImageUriBuilder, actor: FromDb<ActorService>, label: FromDb<LabelService>, graph: FromDb<GraphService>): (db: Database) => FeedService;
     selectPostQb(): import("kysely/dist/cjs/parser/select-parser").QueryBuilderWithSelection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "post">, "post", {}, "post.uri as uri" | "post.cid as cid" | import("kysely").AliasedRawBuilder<FeedItemType, "type"> | "post.uri as postUri" | "post.creator as originatorDid" | "post.creator as postAuthorDid" | "post.replyParent as replyParent" | "post.replyRoot as replyRoot" | "post.sortAt as sortAt">;
     selectFeedItemQb(): import("kysely/dist/cjs/parser/select-parser").QueryBuilderWithSelection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "feed_item">, "post" | "feed_item", {
         type: "post" | "repost";

package/dist/services/feed/views.d.ts

@@ -7,19 +7,20 @@ import { ViewBlocked, ViewNotFound, ViewRecord } from '../../lexicon/types/app/b
 import { PostEmbedViews, FeedGenInfo, FeedRow, MaybePostView, PostInfoMap, RecordEmbedViewRecord, PostBlocksMap, FeedHydrationState, ThreadgateInfoMap, ThreadgateInfo } from './types';
 import { Labels } from '../label';
 import { ImageUriBuilder } from '../../image/uri';
-import { LabelCache } from '../../label-cache';
 import { ActorInfoMap, ActorService } from '../actor';
 import { ListInfoMap, GraphService } from '../graph';
+import { FromDb } from '../types';
 export declare class FeedViews {
     db: Database;
     imgUriBuilder: ImageUriBuilder;
-    labelCache: LabelCache;
-    constructor(db: Database, imgUriBuilder: ImageUriBuilder, labelCache: LabelCache);
-    static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache): (db: Database) => FeedViews;
+    private actor;
+    private graph;
     services: {
         actor: ActorService;
         graph: GraphService;
     };
+    constructor(db: Database, imgUriBuilder: ImageUriBuilder, actor: FromDb<ActorService>, graph: FromDb<GraphService>);
+    static creator(imgUriBuilder: ImageUriBuilder, actor: FromDb<ActorService>, graph: FromDb<GraphService>): (db: Database) => FeedViews;
     formatFeedGeneratorView(info: FeedGenInfo, profiles: ActorInfoMap): GeneratorView | undefined;
     formatFeed(items: FeedRow[], state: FeedHydrationState, viewer: string | null, opts?: {
         usePostViewUnion?: boolean;

package/dist/services/index.d.ts

@@ -1,16 +1,15 @@
-import { Database, PrimaryDatabase } from '../db';
 import { ImageUriBuilder } from '../image/uri';
 import { ActorService } from './actor';
 import { FeedService } from './feed';
 import { GraphService } from './graph';
 import { ModerationService } from './moderation';
-import { LabelService } from './label';
+import { LabelCacheOpts, LabelService } from './label';
 import { ImageInvalidator } from '../image/invalidator';
-import { LabelCache } from '../label-cache';
+import { FromDb, FromDbPrimary } from './types';
 export declare function createServices(resources: {
     imgUriBuilder: ImageUriBuilder;
     imgInvalidator: ImageInvalidator;
-    labelCache: LabelCache;
+    labelCacheOpts: LabelCacheOpts;
 }): Services;
 export declare type Services = {
     actor: FromDb<ActorService>;
@@ -19,6 +18,3 @@ export declare type Services = {
     moderation: FromDbPrimary<ModerationService>;
     label: FromDb<LabelService>;
 };
-declare type FromDb<T> = (db: Database) => T;
-declare type FromDbPrimary<T> = (db: PrimaryDatabase) => T;
-export {};

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

@@ -1,12 +1,18 @@
 import { Database } from '../../db';
 import { Label } from '../../lexicon/types/com/atproto/label/defs';
-import { LabelCache } from '../../label-cache';
+import { ReadThroughCache } from '../../cache/read-through';
+import { Redis } from '../../redis';
 export declare type Labels = Record<string, Label[]>;
+export declare type LabelCacheOpts = {
+    redis: Redis;
+    staleTTL: number;
+    maxTTL: number;
+};
 export declare class LabelService {
     db: Database;
-    cache: LabelCache | null;
-    constructor(db: Database, cache: LabelCache | null);
-    static creator(cache: LabelCache | null): (db: Database) => LabelService;
+    cache: ReadThroughCache<Label[]> | null;
+    constructor(db: Database, cacheOpts: LabelCacheOpts | null);
+    static creator(cacheOpts: LabelCacheOpts | null): (db: Database) => LabelService;
     formatAndCreate(src: string, uri: string, cid: string | null, labels: {
         create?: string[];
         negate?: string[];

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

@@ -165,7 +165,6 @@ export declare class ModerationService {
             actor_sync: import("../../db/tables/actor-sync").ActorSync;
             notification: import("../../db/tables/notification").Notification;
             notification_push_token: import("../../db/tables/notification-push-token").NotificationPushToken;
-            did_cache: import("../../db/tables/did-cache").DidCache;
             label: import("../../db/tables/label").Label;
             moderation_event: ModerationEvent;
             moderation_subject_status: import("../../db/tables/moderation").ModerationSubjectStatus;

package/dist/services/types.d.ts

@@ -0,0 +1,3 @@
+import { Database, PrimaryDatabase } from '../db';
+export declare type FromDb<T> = (db: Database) => T;
+export declare type FromDbPrimary<T> = (db: PrimaryDatabase) => T;

package/dist/services/util/notification.d.ts

@@ -0,0 +1,5 @@
+import { PrimaryDatabase } from '../../db';
+export declare const BEFORE_LAST_SEEN_DAYS = 30;
+export declare const BEFORE_LATEST_UNREAD_DAYS = 180;
+export declare const UNREAD_KEPT_COUNT = 500;
+export declare const tidyNotifications: (db: PrimaryDatabase, did: string) => Promise<void>;