@atproto/bsky 0.0.15 → 0.0.17

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

@@ -7,26 +7,27 @@ 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;
     };
-    formatFeedGeneratorView(info: FeedGenInfo, profiles: ActorInfoMap): GeneratorView;
-    formatFeed(items: FeedRow[], state: FeedHydrationState, opts?: {
-        viewer?: string | null;
+    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;
     }): FeedViewPost[];
-    formatPostView(uri: string, actors: ActorInfoMap, posts: PostInfoMap, threadgates: ThreadgateInfoMap, embeds: PostEmbedViews, labels: Labels, lists: ListInfoMap): PostView | undefined;
-    formatMaybePostView(uri: string, actors: ActorInfoMap, posts: PostInfoMap, threadgates: ThreadgateInfoMap, embeds: PostEmbedViews, labels: Labels, lists: ListInfoMap, blocks: PostBlocksMap, opts?: {
+    formatPostView(uri: string, actors: ActorInfoMap, posts: PostInfoMap, threadgates: ThreadgateInfoMap, embeds: PostEmbedViews, labels: Labels, lists: ListInfoMap, viewer: string | null): PostView | undefined;
+    userReplyDisabled(uri: string, actors: ActorInfoMap, posts: PostInfoMap, threadgates: ThreadgateInfoMap, lists: ListInfoMap, viewer: string | null): boolean | undefined;
+    formatMaybePostView(uri: string, actors: ActorInfoMap, posts: PostInfoMap, threadgates: ThreadgateInfoMap, embeds: PostEmbedViews, labels: Labels, lists: ListInfoMap, blocks: PostBlocksMap, viewer: string | null, opts?: {
         usePostViewUnion?: boolean;
     }): MaybePostView | undefined;
     blockedPost(post: PostView): {
@@ -78,17 +79,6 @@ export declare class FeedViews {
         uri: string;
         cid: string;
         record: import("../../lexicon/types/app/bsky/feed/threadgate").Record;
-        lists: {
-            uri: string;
-            cid: string;
-            name: string;
-            purpose: string;
-            avatar: string | undefined;
-            indexedAt: string;
-            viewer: {
-                muted: boolean;
-                blocked: string | undefined;
-            };
-        }[];
+        lists: import("../../lexicon/types/app/bsky/graph/defs").ListViewBasic[];
     };
 }

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

@@ -2,6 +2,7 @@ import { Database } from '../../db';
 import { ImageUriBuilder } from '../../image/uri';
 import { ListInfo } from './types';
 import { ActorInfoMap } from '../actor';
+import { ListView, ListViewBasic } from '../../lexicon/types/app/bsky/graph/defs';
 export * from './types';
 export declare class GraphService {
     db: Database;
@@ -43,43 +44,18 @@ export declare class GraphService {
         handle: string | null;
         indexedAt: string;
         takedownId: number | null;
-    } & import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list">, "list" | "actor", "list.sortAt as sortAt">, import("kysely").AliasedQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_mute">, "list_mute", import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_mute">, "list_mute", "list_mute.listUri">, "viewerMuted"> | import("kysely").AliasedQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_block">, "list_block", import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_block">, "list_block", "list_block.uri">, "viewerListBlockUri">>;
+    } & import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list">, "list" | "actor", "list.sortAt as sortAt">, import("kysely").AliasedQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_mute">, "list_mute", import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_mute">, "list_mute", "list_mute.listUri">, "viewerMuted"> | import("kysely").AliasedQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_block">, "list_block", import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_block">, "list_block", "list_block.uri">, "viewerListBlockUri"> | import("kysely").AliasedQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_item">, "list_item", import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_item">, "list_item", "list_item.uri">, "viewerInList">>;
     getListItemsQb(): import("kysely/dist/cjs/parser/select-parser").QueryBuilderWithSelection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "list_item"> & Record<"subject", import("../../db/tables/actor").Actor>, "list_item" | "subject", {
         did: string;
         handle: string | null;
         indexedAt: string;
         takedownId: number | null;
-    }, "list_item.cid as cid" | "list_item.sortAt as sortAt">;
+    }, "list_item.uri as uri" | "list_item.cid as cid" | "list_item.sortAt as sortAt">;
     getBlockAndMuteState(pairs: RelationshipPair[], bam?: BlockAndMuteState): Promise<BlockAndMuteState>;
     getBlockState(pairs: RelationshipPair[], bam?: BlockAndMuteState): Promise<BlockAndMuteState>;
     getListViews(listUris: string[], requester: string | null): Promise<{}>;
-    formatListView(list: ListInfo, profiles: ActorInfoMap): {
-        creator: import("../actor").ActorInfo;
-        description: string | undefined;
-        descriptionFacets: any;
-        uri: string;
-        cid: string;
-        name: string;
-        purpose: string;
-        avatar: string | undefined;
-        indexedAt: string;
-        viewer: {
-            muted: boolean;
-            blocked: string | undefined;
-        };
-    };
-    formatListViewBasic(list: ListInfo): {
-        uri: string;
-        cid: string;
-        name: string;
-        purpose: string;
-        avatar: string | undefined;
-        indexedAt: string;
-        viewer: {
-            muted: boolean;
-            blocked: string | undefined;
-        };
-    };
+    formatListView(list: ListInfo, profiles: ActorInfoMap): ListView | undefined;
+    formatListViewBasic(list: ListInfo): ListViewBasic;
 }
 export declare type RelationshipPair = [didA: string, didB: string];
 export declare class BlockAndMuteState {

package/dist/services/graph/types.d.ts

@@ -3,5 +3,6 @@ import { List } from '../../db/tables/list';
 export declare type ListInfo = Selectable<List> & {
     viewerMuted: string | null;
     viewerListBlockUri: string | null;
+    viewerInList: string | null;
 };
 export declare type ListInfoMap = Record<string, ListInfo>;

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

@@ -1,13 +1,13 @@
-import { Selectable } from 'kysely';
 import { CID } from 'multiformats/cid';
 import { AtUri } from '@atproto/syntax';
 import { PrimaryDatabase } from '../../db';
-import { ModerationAction, ModerationReport } from '../../db/tables/moderation';
 import { ModerationViews } from './views';
 import { ImageUriBuilder } from '../../image/uri';
+import { Main as StrongRef } from '../../lexicon/types/com/atproto/repo/strongRef';
 import { ImageInvalidator } from '../../image/invalidator';
 import { RepoRef, RepoBlobRef } from '../../lexicon/types/com/atproto/admin/defs';
-import { Main as StrongRef } from '../../lexicon/types/com/atproto/repo/strongRef';
+import { ModEventType, ModerationEventRow, ModerationEventRowWithHandle, ModerationSubjectStatusRow, ReversibleModerationEvent, SubjectInfo } from './types';
+import { ModerationEvent } from '../../db/tables/moderation';
 export declare class ModerationService {
     db: PrimaryDatabase;
     imgUriBuilder: ImageUriBuilder;
@@ -15,52 +15,52 @@ export declare class ModerationService {
     constructor(db: PrimaryDatabase, imgUriBuilder: ImageUriBuilder, imgInvalidator: ImageInvalidator);
     static creator(imgUriBuilder: ImageUriBuilder, imgInvalidator: ImageInvalidator): (db: PrimaryDatabase) => ModerationService;
     views: ModerationViews;
-    getAction(id: number): Promise<ModerationActionRow | undefined>;
-    getActionOrThrow(id: number): Promise<ModerationActionRow>;
-    getActions(opts: {
+    getEvent(id: number): Promise<ModerationEventRow | undefined>;
+    getEventOrThrow(id: number): Promise<ModerationEventRow>;
+    getEvents(opts: {
         subject?: string;
+        createdBy?: string;
         limit: number;
         cursor?: string;
-    }): Promise<ModerationActionRow[]>;
-    getReport(id: number): Promise<ModerationReportRow | undefined>;
-    getReports(opts: {
-        subject?: string;
-        resolved?: boolean;
-        actionType?: string;
-        limit: number;
+        includeAllUserRecords: boolean;
+        types: ModerationEvent['action'][];
+        sortDirection?: 'asc' | 'desc';
+    }): Promise<{
         cursor?: string;
-        ignoreSubjects?: string[];
-        reverse?: boolean;
-        reporters?: string[];
-        actionedBy?: string;
-    }): Promise<ModerationReportRowWithHandle[]>;
-    getReportOrThrow(id: number): Promise<ModerationReportRow>;
-    getCurrentActions(subject: {
+        events: ModerationEventRowWithHandle[];
+    }>;
+    getReport(id: number): Promise<ModerationEventRow | undefined>;
+    getCurrentStatus(subject: {
         did: string;
     } | {
         uri: AtUri;
     } | {
         cids: CID[];
     }): Promise<{
+        did: string;
         id: number;
-        action: "com.atproto.admin.defs#takedown" | "com.atproto.admin.defs#flag" | "com.atproto.admin.defs#acknowledge" | "com.atproto.admin.defs#escalate";
-        reason: string;
-        createdBy: string;
         createdAt: string;
-        durationInHours: number | null;
-        createLabelVals: string | null;
-        negateLabelVals: string | null;
-        subjectCid: string | null;
-        subjectDid: string;
-        subjectType: "com.atproto.repo.strongRef" | "com.atproto.admin.defs#repoRef";
-        subjectUri: string | null;
-        reversedAt: string | null;
-        reversedBy: string | null;
-        reversedReason: string | null;
-        expiresAt: string | null;
+        updatedAt: string;
+        reviewState: "com.atproto.admin.defs#reviewOpen" | "com.atproto.admin.defs#reviewEscalated" | "com.atproto.admin.defs#reviewClosed";
+        blobCids: string[] | null;
+        comment: string | null;
+        lastReportedAt: string | null;
+        lastReviewedAt: string | null;
+        muteUntil: string | null;
+        lastReviewedBy: string | null;
+        takendown: boolean;
+        suspendUntil: string | null;
+        recordCid: string | null;
+        recordPath: string;
     }[]>;
-    logAction(info: {
-        action: ModerationActionRow['action'];
+    buildSubjectInfo(subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+        cid: CID;
+    }, subjectBlobCids?: CID[]): SubjectInfo;
+    logEvent(info: {
+        event: ModEventType;
         subject: {
             did: string;
         } | {
@@ -68,19 +68,31 @@ export declare class ModerationService {
             cid: CID;
         };
         subjectBlobCids?: CID[];
-        reason: string;
-        createLabelVals?: string[];
-        negateLabelVals?: string[];
         createdBy: string;
         createdAt?: Date;
-        durationInHours?: number;
-    }): Promise<ModerationActionRow>;
-    getActionsDueForReversal(): Promise<ModerationActionRow[]>;
-    revertAction({ id, createdBy, createdAt, reason, }: ReversibleModerationAction): Promise<{
-        result: ModerationActionRow;
+    }): Promise<ModerationEventRow>;
+    getLastReversibleEventForSubject({ did, muteUntil, recordPath, suspendUntil, }: ModerationSubjectStatusRow): Promise<{
+        id: number;
+        createdBy: string;
+        createdAt: string;
+        comment: string | null;
+        createLabelVals: string | null;
+        negateLabelVals: string | null;
+        durationInHours: number | null;
+        action: "com.atproto.admin.defs#modEventTakedown" | "com.atproto.admin.defs#modEventReverseTakedown" | "com.atproto.admin.defs#modEventComment" | "com.atproto.admin.defs#modEventReport" | "com.atproto.admin.defs#modEventLabel" | "com.atproto.admin.defs#modEventAcknowledge" | "com.atproto.admin.defs#modEventEscalate" | "com.atproto.admin.defs#modEventMute" | "com.atproto.admin.defs#modEventEmail";
+        subjectCid: string | null;
+        subjectDid: string;
+        subjectType: "com.atproto.repo.strongRef" | "com.atproto.admin.defs#repoRef";
+        subjectUri: string | null;
+        expiresAt: string | null;
+        meta: Record<string, string | boolean> | null;
+        legacyRefId: number | null;
+    } | null | undefined>;
+    getSubjectsDueForReversal(): Promise<ModerationSubjectStatusRow[]>;
+    revertState({ createdBy, createdAt, comment, action, subject, }: ReversibleModerationEvent): Promise<{
+        result: ModerationEventRow;
         restored?: TakedownSubjects;
     }>;
-    logReverseAction(info: ReversibleModerationAction): Promise<ModerationActionRow>;
     takedownRepo(info: {
         takedownId: number;
         did: string;
@@ -97,14 +109,8 @@ export declare class ModerationService {
     reverseTakedownRecord(info: {
         uri: AtUri;
     }): Promise<void>;
-    resolveReports(info: {
-        reportIds: number[];
-        actionId: number;
-        createdBy: string;
-        createdAt?: Date;
-    }): Promise<void>;
     report(info: {
-        reasonType: ModerationReportRow['reasonType'];
+        reasonType: NonNullable<ModerationEventRow['meta']>['reportType'];
         reason?: string;
         subject: {
             did: string;
@@ -114,28 +120,84 @@ export declare class ModerationService {
         };
         reportedBy: string;
         createdAt?: Date;
-    }): Promise<ModerationReportRow>;
+    }): Promise<ModerationEventRow>;
+    getSubjectStatuses({ cursor, limit, takendown, reviewState, reviewedAfter, reviewedBefore, reportedAfter, reportedBefore, includeMuted, ignoreSubjects, sortDirection, lastReviewedBy, sortField, subject, }: {
+        cursor?: string;
+        limit?: number;
+        takendown?: boolean;
+        reviewedBefore?: string;
+        reviewState?: ModerationSubjectStatusRow['reviewState'];
+        reviewedAfter?: string;
+        reportedAfter?: string;
+        reportedBefore?: string;
+        includeMuted?: boolean;
+        subject?: string;
+        ignoreSubjects?: string[];
+        sortDirection: 'asc' | 'desc';
+        lastReviewedBy?: string;
+        sortField: 'lastReviewedAt' | 'lastReportedAt';
+    }): Promise<{
+        statuses: (import("kysely").Selection<{
+            record: import("../../db/tables/record").Record;
+            subscription: import("../../db/tables/subscription").Subscription;
+            post: import("../../db/tables/post").Post;
+            duplicate_record: import("../../db/tables/duplicate-record").DuplicateRecord;
+            profile: import("../../db/tables/profile").Profile;
+            profile_agg: import("../../db/tables/profile-agg").ProfileAgg;
+            post_embed_image: import("../../db/tables/post-embed").PostEmbedImage;
+            post_embed_external: import("../../db/tables/post-embed").PostEmbedExternal;
+            post_embed_record: import("../../db/tables/post-embed").PostEmbedRecord;
+            post_agg: import("../../db/tables/post-agg").PostAgg;
+            repost: import("../../db/tables/repost").Repost;
+            thread_gate: import("../../db/tables/thread-gate").ThreadGate;
+            feed_item: import("../../db/tables/feed-item").FeedItem;
+            follow: import("../../db/tables/follow").Follow;
+            like: import("../../db/tables/like").Like;
+            list: import("../../db/tables/list").List;
+            list_item: import("../../db/tables/list-item").ListItem;
+            list_mute: import("../../db/tables/list-mute").ListMute;
+            list_block: import("../../db/tables/list-block").ListBlock;
+            mute: import("../../db/tables/mute").Mute;
+            actor_block: import("../../db/tables/actor-block").ActorBlock;
+            feed_generator: import("../../db/tables/feed-generator").FeedGenerator;
+            actor: import("kysely/dist/cjs/util/type-utils").Nullable<import("../../db/tables/actor").Actor>;
+            actor_state: import("../../db/tables/actor-state").ActorState;
+            actor_sync: import("../../db/tables/actor-sync").ActorSync;
+            notification: import("../../db/tables/notification").Notification;
+            notification_push_token: import("../../db/tables/notification-push-token").NotificationPushToken;
+            label: import("../../db/tables/label").Label;
+            moderation_event: ModerationEvent;
+            moderation_subject_status: import("../../db/tables/moderation").ModerationSubjectStatus;
+            algo_whats_hot_view: import("../../db/tables/algo").AlgoWhatsHotView;
+            view_param: import("../../db/tables/view-param").ViewParam;
+            suggested_follow: import("../../db/tables/suggested-follow").SuggestedFollow;
+            suggested_feed: import("../../db/tables/suggested-feed").SuggestedFeed;
+        }, "actor" | "moderation_subject_status", "actor.handle as handle"> & {
+            did: string;
+            id: number;
+            createdAt: string;
+            updatedAt: string;
+            reviewState: "com.atproto.admin.defs#reviewOpen" | "com.atproto.admin.defs#reviewEscalated" | "com.atproto.admin.defs#reviewClosed";
+            blobCids: string[] | null;
+            comment: string | null;
+            lastReportedAt: string | null;
+            lastReviewedAt: string | null;
+            muteUntil: string | null;
+            lastReviewedBy: string | null;
+            takendown: boolean;
+            suspendUntil: string | null;
+            recordCid: string | null;
+            recordPath: string;
+        })[];
+        cursor: string | undefined;
+    }>;
+    isSubjectTakendown(subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+    }): Promise<boolean>;
 }
 export declare type TakedownSubjects = {
     did: string;
     subjects: (RepoRef | RepoBlobRef | StrongRef)[];
 };
-export declare type ModerationActionRow = Selectable<ModerationAction>;
-export declare type ReversibleModerationAction = Pick<ModerationActionRow, 'id' | 'createdBy' | 'reason'> & {
-    createdAt?: Date;
-};
-export declare type ModerationReportRow = Selectable<ModerationReport>;
-export declare type ModerationReportRowWithHandle = ModerationReportRow & {
-    handle?: string | null;
-};
-export declare type SubjectInfo = {
-    subjectType: 'com.atproto.admin.defs#repoRef';
-    subjectDid: string;
-    subjectUri: null;
-    subjectCid: null;
-} | {
-    subjectType: 'com.atproto.repo.strongRef';
-    subjectDid: string;
-    subjectUri: string;
-    subjectCid: string;
-};

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

@@ -0,0 +1,36 @@
+import { Cursor, GenericKeyset } from '../../db/pagination';
+declare type StatusKeysetParam = {
+    lastReviewedAt: string | null;
+    lastReportedAt: string | null;
+    id: number;
+};
+export declare class StatusKeyset extends GenericKeyset<StatusKeysetParam, Cursor> {
+    labelResult(result: StatusKeysetParam): Cursor;
+    labeledResultToCursor(labeled: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+    cursorToLabeledResult(cursor: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+    unpackCursor(cursorStr?: string): Cursor | undefined;
+    getSql(labeled?: Cursor, direction?: 'asc' | 'desc'): import("kysely").RawBuilder<unknown> | undefined;
+}
+declare type TimeIdKeysetParam = {
+    id: number;
+    createdAt: string;
+};
+declare type TimeIdResult = TimeIdKeysetParam;
+export declare class TimeIdKeyset extends GenericKeyset<TimeIdKeysetParam, Cursor> {
+    labelResult(result: TimeIdResult): Cursor;
+    labeledResultToCursor(labeled: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+    cursorToLabeledResult(cursor: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { AtUri } from '@atproto/syntax';
+import { PrimaryDatabase } from '../../db';
+import { ModerationSubjectStatus } from '../../db/tables/moderation';
+import { ModerationEventRow } from './types';
+import { CID } from 'multiformats/cid';
+export declare const adjustModerationSubjectStatus: (db: PrimaryDatabase, moderationEvent: ModerationEventRow, blobCids?: CID[]) => Promise<import("kysely").InsertResult | null>;
+declare type ModerationSubjectStatusFilter = Pick<ModerationSubjectStatus, 'did'> | Pick<ModerationSubjectStatus, 'did' | 'recordPath'> | Pick<ModerationSubjectStatus, 'did' | 'recordPath' | 'recordCid'>;
+export declare const getModerationSubjectStatus: (db: PrimaryDatabase, filters: ModerationSubjectStatusFilter) => Promise<{} | undefined>;
+export declare const getStatusIdentifierFromSubject: (subject: string | AtUri) => {
+    did: string;
+    recordPath: string;
+};
+export {};

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

@@ -0,0 +1,35 @@
+import { Selectable } from 'kysely';
+import { ModerationEvent, ModerationSubjectStatus } from '../../db/tables/moderation';
+import { AtUri } from '@atproto/syntax';
+import { CID } from 'multiformats/cid';
+import { ComAtprotoAdminDefs } from '@atproto/api';
+export declare type SubjectInfo = {
+    subjectType: 'com.atproto.admin.defs#repoRef';
+    subjectDid: string;
+    subjectUri: null;
+    subjectCid: null;
+} | {
+    subjectType: 'com.atproto.repo.strongRef';
+    subjectDid: string;
+    subjectUri: string;
+    subjectCid: string;
+};
+export declare type ModerationEventRow = Selectable<ModerationEvent>;
+export declare type ReversibleModerationEvent = Pick<ModerationEventRow, 'createdBy' | 'comment' | 'action'> & {
+    createdAt?: Date;
+    subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+        cid: CID;
+    };
+};
+export declare type ModerationEventRowWithHandle = ModerationEventRow & {
+    subjectHandle?: string | null;
+    creatorHandle?: string | null;
+};
+export declare type ModerationSubjectStatusRow = Selectable<ModerationSubjectStatus>;
+export declare type ModerationSubjectStatusRowWithHandle = ModerationSubjectStatusRow & {
+    handle: string | null;
+};
+export declare type ModEventType = ComAtprotoAdminDefs.ModEventTakedown | ComAtprotoAdminDefs.ModEventAcknowledge | ComAtprotoAdminDefs.ModEventEscalate | ComAtprotoAdminDefs.ModEventComment | ComAtprotoAdminDefs.ModEventLabel | ComAtprotoAdminDefs.ModEventReport | ComAtprotoAdminDefs.ModEventMute | ComAtprotoAdminDefs.ModEventReverseTakedown;

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

@@ -1,37 +1,41 @@
-import { Selectable } from 'kysely';
 import { BlobRef } from '@atproto/lexicon';
 import { Database } from '../../db';
 import { Actor } from '../../db/tables/actor';
 import { Record as RecordRow } from '../../db/tables/record';
-import { ModerationAction } from '../../db/tables/moderation';
-import { RepoView, RepoViewDetail, RecordView, RecordViewDetail, ActionView, ActionViewDetail, ReportView, ReportViewDetail, BlobView } from '../../lexicon/types/com/atproto/admin/defs';
+import { ModEventView, RepoView, RepoViewDetail, RecordView, RecordViewDetail, ReportViewDetail, BlobView, SubjectStatusView, ModEventViewDetail } from '../../lexicon/types/com/atproto/admin/defs';
 import { OutputSchema as ReportOutput } from '../../lexicon/types/com/atproto/moderation/createReport';
 import { Label } from '../../lexicon/types/com/atproto/label/defs';
-import { ModerationReportRowWithHandle } from '.';
+import { ModerationEventRowWithHandle, ModerationSubjectStatusRowWithHandle } from './types';
 export declare class ModerationViews {
     private db;
     constructor(db: Database);
     repo(result: RepoResult): Promise<RepoView>;
     repo(result: RepoResult[]): Promise<RepoView[]>;
+    event(result: EventResult): Promise<ModEventView>;
+    event(result: EventResult[]): Promise<ModEventView[]>;
+    eventDetail(result: EventResult): Promise<ModEventViewDetail>;
     repoDetail(result: RepoResult): Promise<RepoViewDetail>;
     record(result: RecordResult): Promise<RecordView>;
     record(result: RecordResult[]): Promise<RecordView[]>;
     recordDetail(result: RecordResult): Promise<RecordViewDetail>;
-    action(result: ActionResult): Promise<ActionView>;
-    action(result: ActionResult[]): Promise<ActionView[]>;
-    actionDetail(result: ActionResult): Promise<ActionViewDetail>;
-    report(result: ReportResult): Promise<ReportView>;
-    report(result: ReportResult[]): Promise<ReportView[]>;
     reportPublic(report: ReportResult): ReportOutput;
-    reportDetail(result: ReportResult): Promise<ReportViewDetail>;
     subject(result: SubjectResult): Promise<SubjectView>;
     blob(blobs: BlobRef[]): Promise<BlobView[]>;
     labels(subject: string, includeNeg?: boolean): Promise<Label[]>;
+    getSubjectStatus(subject: {
+        did: string;
+        recordPath?: string;
+    } | {
+        did: string;
+        recordPath?: string;
+    }[]): Promise<ModerationSubjectStatusRowWithHandle[]>;
+    subjectStatus(result: ModerationSubjectStatusRowWithHandle): SubjectStatusView;
+    subjectStatus(result: ModerationSubjectStatusRowWithHandle[]): SubjectStatusView[];
 }
 declare type RepoResult = Actor;
-declare type ActionResult = Selectable<ModerationAction>;
-declare type ReportResult = ModerationReportRowWithHandle;
+declare type EventResult = ModerationEventRowWithHandle;
+declare type ReportResult = ModerationEventRowWithHandle;
 declare type RecordResult = RecordRow;
-declare type SubjectResult = Pick<ActionResult & ReportResult, 'id' | 'subjectType' | 'subjectDid' | 'subjectUri' | 'subjectCid'>;
-declare type SubjectView = ActionViewDetail['subject'] & ReportViewDetail['subject'];
+declare type SubjectResult = Pick<EventResult & ReportResult, 'id' | 'subjectType' | 'subjectDid' | 'subjectUri' | 'subjectCid'>;
+declare type SubjectView = ModEventViewDetail['subject'] & ReportViewDetail['subject'];
 export {};

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>;