@atproto/bsky 0.0.15 → 0.0.17

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

@@ -30,6 +30,7 @@ export declare function validatePostView(v: unknown): ValidationResult;
 export interface ViewerState {
     repost?: string;
     like?: string;
+    replyDisabled?: boolean;
     [k: string]: unknown;
 }
 export declare function isViewerState(v: unknown): v is ViewerState;
@@ -75,7 +76,6 @@ export interface ThreadViewPost {
         $type: string;
         [k: string]: unknown;
     })[];
-    viewer?: ViewerThreadState;
     [k: string]: unknown;
 }
 export declare function isThreadViewPost(v: unknown): v is ThreadViewPost;
@@ -102,12 +102,6 @@ export interface BlockedAuthor {
 }
 export declare function isBlockedAuthor(v: unknown): v is BlockedAuthor;
 export declare function validateBlockedAuthor(v: unknown): ValidationResult;
-export interface ViewerThreadState {
-    canReply?: boolean;
-    [k: string]: unknown;
-}
-export declare function isViewerThreadState(v: unknown): v is ViewerThreadState;
-export declare function validateViewerThreadState(v: unknown): ValidationResult;
 export interface GeneratorView {
     uri: string;
     cid: string;

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

@@ -29,6 +29,7 @@ export interface ListView {
 export declare function isListView(v: unknown): v is ListView;
 export declare function validateListView(v: unknown): ValidationResult;
 export interface ListItemView {
+    uri: string;
     subject: AppBskyActorDefs.ProfileView;
     [k: string]: unknown;
 }

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

@@ -10,71 +10,46 @@ export interface StatusAttr {
 }
 export declare function isStatusAttr(v: unknown): v is StatusAttr;
 export declare function validateStatusAttr(v: unknown): ValidationResult;
-export interface ActionView {
+export interface ModEventView {
     id: number;
-    action: ActionType;
-    durationInHours?: number;
+    event: ModEventTakedown | ModEventReverseTakedown | ModEventComment | ModEventReport | ModEventLabel | ModEventAcknowledge | ModEventEscalate | ModEventMute | ModEventEmail | {
+        $type: string;
+        [k: string]: unknown;
+    };
     subject: RepoRef | ComAtprotoRepoStrongRef.Main | {
         $type: string;
         [k: string]: unknown;
     };
     subjectBlobCids: string[];
-    createLabelVals?: string[];
-    negateLabelVals?: string[];
-    reason: string;
     createdBy: string;
     createdAt: string;
-    reversal?: ActionReversal;
-    resolvedReportIds: number[];
+    creatorHandle?: string;
+    subjectHandle?: string;
     [k: string]: unknown;
 }
-export declare function isActionView(v: unknown): v is ActionView;
-export declare function validateActionView(v: unknown): ValidationResult;
-export interface ActionViewDetail {
+export declare function isModEventView(v: unknown): v is ModEventView;
+export declare function validateModEventView(v: unknown): ValidationResult;
+export interface ModEventViewDetail {
     id: number;
-    action: ActionType;
-    durationInHours?: number;
+    event: ModEventTakedown | ModEventReverseTakedown | ModEventComment | ModEventReport | ModEventLabel | ModEventAcknowledge | ModEventEscalate | ModEventMute | {
+        $type: string;
+        [k: string]: unknown;
+    };
     subject: RepoView | RepoViewNotFound | RecordView | RecordViewNotFound | {
         $type: string;
         [k: string]: unknown;
     };
     subjectBlobs: BlobView[];
-    createLabelVals?: string[];
-    negateLabelVals?: string[];
-    reason: string;
     createdBy: string;
     createdAt: string;
-    reversal?: ActionReversal;
-    resolvedReports: ReportView[];
-    [k: string]: unknown;
-}
-export declare function isActionViewDetail(v: unknown): v is ActionViewDetail;
-export declare function validateActionViewDetail(v: unknown): ValidationResult;
-export interface ActionViewCurrent {
-    id: number;
-    action: ActionType;
-    durationInHours?: number;
     [k: string]: unknown;
 }
-export declare function isActionViewCurrent(v: unknown): v is ActionViewCurrent;
-export declare function validateActionViewCurrent(v: unknown): ValidationResult;
-export interface ActionReversal {
-    reason: string;
-    createdBy: string;
-    createdAt: string;
-    [k: string]: unknown;
-}
-export declare function isActionReversal(v: unknown): v is ActionReversal;
-export declare function validateActionReversal(v: unknown): ValidationResult;
-export declare type ActionType = 'lex:com.atproto.admin.defs#takedown' | 'lex:com.atproto.admin.defs#flag' | 'lex:com.atproto.admin.defs#acknowledge' | 'lex:com.atproto.admin.defs#escalate' | (string & {});
-export declare const TAKEDOWN = "com.atproto.admin.defs#takedown";
-export declare const FLAG = "com.atproto.admin.defs#flag";
-export declare const ACKNOWLEDGE = "com.atproto.admin.defs#acknowledge";
-export declare const ESCALATE = "com.atproto.admin.defs#escalate";
+export declare function isModEventViewDetail(v: unknown): v is ModEventViewDetail;
+export declare function validateModEventViewDetail(v: unknown): ValidationResult;
 export interface ReportView {
     id: number;
     reasonType: ComAtprotoModerationDefs.ReasonType;
-    reason?: string;
+    comment?: string;
     subjectRepoHandle?: string;
     subject: RepoRef | ComAtprotoRepoStrongRef.Main | {
         $type: string;
@@ -87,17 +62,40 @@ export interface ReportView {
 }
 export declare function isReportView(v: unknown): v is ReportView;
 export declare function validateReportView(v: unknown): ValidationResult;
+export interface SubjectStatusView {
+    id: number;
+    subject: RepoRef | ComAtprotoRepoStrongRef.Main | {
+        $type: string;
+        [k: string]: unknown;
+    };
+    subjectBlobCids?: string[];
+    subjectRepoHandle?: string;
+    updatedAt: string;
+    createdAt: string;
+    reviewState: SubjectReviewState;
+    comment?: string;
+    muteUntil?: string;
+    lastReviewedBy?: string;
+    lastReviewedAt?: string;
+    lastReportedAt?: string;
+    takendown?: boolean;
+    suspendUntil?: string;
+    [k: string]: unknown;
+}
+export declare function isSubjectStatusView(v: unknown): v is SubjectStatusView;
+export declare function validateSubjectStatusView(v: unknown): ValidationResult;
 export interface ReportViewDetail {
     id: number;
     reasonType: ComAtprotoModerationDefs.ReasonType;
-    reason?: string;
+    comment?: string;
     subject: RepoView | RepoViewNotFound | RecordView | RecordViewNotFound | {
         $type: string;
         [k: string]: unknown;
     };
+    subjectStatus?: SubjectStatusView;
     reportedBy: string;
     createdAt: string;
-    resolvedByActions: ActionView[];
+    resolvedByActions: ModEventView[];
     [k: string]: unknown;
 }
 export declare function isReportViewDetail(v: unknown): v is ReportViewDetail;
@@ -199,15 +197,13 @@ export interface RecordViewNotFound {
 export declare function isRecordViewNotFound(v: unknown): v is RecordViewNotFound;
 export declare function validateRecordViewNotFound(v: unknown): ValidationResult;
 export interface Moderation {
-    currentAction?: ActionViewCurrent;
+    subjectStatus?: SubjectStatusView;
     [k: string]: unknown;
 }
 export declare function isModeration(v: unknown): v is Moderation;
 export declare function validateModeration(v: unknown): ValidationResult;
 export interface ModerationDetail {
-    currentAction?: ActionViewCurrent;
-    actions: ActionView[];
-    reports: ReportView[];
+    subjectStatus?: SubjectStatusView;
     [k: string]: unknown;
 }
 export declare function isModerationDetail(v: unknown): v is ModerationDetail;
@@ -241,3 +237,73 @@ export interface VideoDetails {
 }
 export declare function isVideoDetails(v: unknown): v is VideoDetails;
 export declare function validateVideoDetails(v: unknown): ValidationResult;
+export declare type SubjectReviewState = 'lex:com.atproto.admin.defs#reviewOpen' | 'lex:com.atproto.admin.defs#reviewEscalated' | 'lex:com.atproto.admin.defs#reviewClosed' | (string & {});
+export declare const REVIEWOPEN = "com.atproto.admin.defs#reviewOpen";
+export declare const REVIEWESCALATED = "com.atproto.admin.defs#reviewEscalated";
+export declare const REVIEWCLOSED = "com.atproto.admin.defs#reviewClosed";
+export interface ModEventTakedown {
+    comment?: string;
+    durationInHours?: number;
+    [k: string]: unknown;
+}
+export declare function isModEventTakedown(v: unknown): v is ModEventTakedown;
+export declare function validateModEventTakedown(v: unknown): ValidationResult;
+export interface ModEventReverseTakedown {
+    comment?: string;
+    [k: string]: unknown;
+}
+export declare function isModEventReverseTakedown(v: unknown): v is ModEventReverseTakedown;
+export declare function validateModEventReverseTakedown(v: unknown): ValidationResult;
+export interface ModEventComment {
+    comment: string;
+    sticky?: boolean;
+    [k: string]: unknown;
+}
+export declare function isModEventComment(v: unknown): v is ModEventComment;
+export declare function validateModEventComment(v: unknown): ValidationResult;
+export interface ModEventReport {
+    comment?: string;
+    reportType: ComAtprotoModerationDefs.ReasonType;
+    [k: string]: unknown;
+}
+export declare function isModEventReport(v: unknown): v is ModEventReport;
+export declare function validateModEventReport(v: unknown): ValidationResult;
+export interface ModEventLabel {
+    comment?: string;
+    createLabelVals: string[];
+    negateLabelVals: string[];
+    [k: string]: unknown;
+}
+export declare function isModEventLabel(v: unknown): v is ModEventLabel;
+export declare function validateModEventLabel(v: unknown): ValidationResult;
+export interface ModEventAcknowledge {
+    comment?: string;
+    [k: string]: unknown;
+}
+export declare function isModEventAcknowledge(v: unknown): v is ModEventAcknowledge;
+export declare function validateModEventAcknowledge(v: unknown): ValidationResult;
+export interface ModEventEscalate {
+    comment?: string;
+    [k: string]: unknown;
+}
+export declare function isModEventEscalate(v: unknown): v is ModEventEscalate;
+export declare function validateModEventEscalate(v: unknown): ValidationResult;
+export interface ModEventMute {
+    comment?: string;
+    durationInHours: number;
+    [k: string]: unknown;
+}
+export declare function isModEventMute(v: unknown): v is ModEventMute;
+export declare function validateModEventMute(v: unknown): ValidationResult;
+export interface ModEventUnmute {
+    comment?: string;
+    [k: string]: unknown;
+}
+export declare function isModEventUnmute(v: unknown): v is ModEventUnmute;
+export declare function validateModEventUnmute(v: unknown): ValidationResult;
+export interface ModEventEmail {
+    subjectLine: string;
+    [k: string]: unknown;
+}
+export declare function isModEventEmail(v: unknown): v is ModEventEmail;
+export declare function validateModEventEmail(v: unknown): ValidationResult;

package/dist/lexicon/types/com/atproto/admin/{resolveModerationReports.d.ts → deleteAccount.d.ts}

@@ -1,31 +1,20 @@
 import express from 'express';
 import { HandlerAuth } from '@atproto/xrpc-server';
-import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
 }
 export interface InputSchema {
-    actionId: number;
-    reportIds: number[];
-    createdBy: string;
+    did: string;
     [k: string]: unknown;
 }
-export declare type OutputSchema = ComAtprotoAdminDefs.ActionView;
 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;
 }
-export declare type HandlerOutput = HandlerError | HandlerSuccess;
+export declare type HandlerOutput = HandlerError | void;
 export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
     auth: HA;
     params: QueryParams;

package/dist/lexicon/types/com/atproto/admin/{takeModerationAction.d.ts → emitModerationEvent.d.ts}

@@ -5,20 +5,19 @@ import * as ComAtprotoRepoStrongRef from '../repo/strongRef';
 export interface QueryParams {
 }
 export interface InputSchema {
-    action: 'com.atproto.admin.defs#takedown' | 'com.atproto.admin.defs#flag' | 'com.atproto.admin.defs#acknowledge' | (string & {});
+    event: ComAtprotoAdminDefs.ModEventTakedown | ComAtprotoAdminDefs.ModEventAcknowledge | ComAtprotoAdminDefs.ModEventEscalate | ComAtprotoAdminDefs.ModEventComment | ComAtprotoAdminDefs.ModEventLabel | ComAtprotoAdminDefs.ModEventReport | ComAtprotoAdminDefs.ModEventMute | ComAtprotoAdminDefs.ModEventReverseTakedown | ComAtprotoAdminDefs.ModEventUnmute | ComAtprotoAdminDefs.ModEventEmail | {
+        $type: string;
+        [k: string]: unknown;
+    };
     subject: ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main | {
         $type: string;
         [k: string]: unknown;
     };
     subjectBlobCids?: string[];
-    createLabelVals?: string[];
-    negateLabelVals?: string[];
-    reason: string;
-    durationInHours?: number;
     createdBy: string;
     [k: string]: unknown;
 }
-export declare type OutputSchema = ComAtprotoAdminDefs.ActionView;
+export declare type OutputSchema = ComAtprotoAdminDefs.ModEventView;
 export interface HandlerInput {
     encoding: 'application/json';
     body: InputSchema;

package/dist/lexicon/types/com/atproto/admin/{getModerationAction.d.ts → getModerationEvent.d.ts}

@@ -5,7 +5,7 @@ export interface QueryParams {
     id: number;
 }
 export declare type InputSchema = undefined;
-export declare type OutputSchema = ComAtprotoAdminDefs.ActionViewDetail;
+export declare type OutputSchema = ComAtprotoAdminDefs.ModEventViewDetail;
 export declare type HandlerInput = undefined;
 export interface HandlerSuccess {
     encoding: 'application/json';

package/dist/lexicon/types/com/atproto/admin/{getModerationActions.d.ts → queryModerationEvents.d.ts}

@@ -2,14 +2,18 @@ import express from 'express';
 import { HandlerAuth } from '@atproto/xrpc-server';
 import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
+    types?: string[];
+    createdBy?: string;
+    sortDirection: 'asc' | 'desc';
     subject?: string;
+    includeAllUserRecords: boolean;
     limit: number;
     cursor?: string;
 }
 export declare type InputSchema = undefined;
 export interface OutputSchema {
     cursor?: string;
-    actions: ComAtprotoAdminDefs.ActionView[];
+    events: ComAtprotoAdminDefs.ModEventView[];
     [k: string]: unknown;
 }
 export declare type HandlerInput = undefined;

package/dist/lexicon/types/com/atproto/admin/{getModerationReports.d.ts → queryModerationStatuses.d.ts}

@@ -3,19 +3,25 @@ import { HandlerAuth } from '@atproto/xrpc-server';
 import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
     subject?: string;
+    comment?: string;
+    reportedAfter?: string;
+    reportedBefore?: string;
+    reviewedAfter?: string;
+    reviewedBefore?: string;
+    includeMuted?: boolean;
+    reviewState?: string;
     ignoreSubjects?: string[];
-    actionedBy?: string;
-    reporters?: string[];
-    resolved?: boolean;
-    actionType?: 'com.atproto.admin.defs#takedown' | 'com.atproto.admin.defs#flag' | 'com.atproto.admin.defs#acknowledge' | 'com.atproto.admin.defs#escalate' | (string & {});
+    lastReviewedBy?: string;
+    sortField: 'lastReviewedAt' | 'lastReportedAt';
+    sortDirection: 'asc' | 'desc';
+    takendown?: boolean;
     limit: number;
     cursor?: string;
-    reverse?: boolean;
 }
 export declare type InputSchema = undefined;
 export interface OutputSchema {
     cursor?: string;
-    reports: ComAtprotoAdminDefs.ReportView[];
+    subjectStatuses: ComAtprotoAdminDefs.SubjectStatusView[];
     [k: string]: unknown;
 }
 export declare type HandlerInput = undefined;

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

@@ -6,6 +6,7 @@ export interface InputSchema {
     recipientDid: string;
     content: string;
     subject?: string;
+    senderDid: string;
     [k: string]: unknown;
 }
 export interface OutputSchema {

package/dist/lexicon/types/com/atproto/{admin/getModerationReport.d.ts → temp/importRepo.d.ts}

@@ -1,15 +1,18 @@
+/// <reference types="node" />
 import express from 'express';
+import stream from 'stream';
 import { HandlerAuth } from '@atproto/xrpc-server';
-import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
-    id: number;
+    did: string;
+}
+export declare type InputSchema = string | Uint8Array;
+export interface HandlerInput {
+    encoding: 'application/vnd.ipld.car';
+    body: stream.Readable;
 }
-export declare type InputSchema = undefined;
-export declare type OutputSchema = ComAtprotoAdminDefs.ReportViewDetail;
-export declare type HandlerInput = undefined;
 export interface HandlerSuccess {
-    encoding: 'application/json';
-    body: OutputSchema;
+    encoding: 'text/plain';
+    body: Uint8Array | stream.Readable;
     headers?: {
         [key: string]: string;
     };

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/{admin/reverseModerationAction.d.ts → temp/transferAccount.d.ts}

@@ -1,15 +1,20 @@
 import express from 'express';
 import { HandlerAuth } from '@atproto/xrpc-server';
-import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
 }
 export interface InputSchema {
-    id: number;
-    reason: string;
-    createdBy: string;
+    handle: string;
+    did: string;
+    plcOp: {};
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    accessJwt: string;
+    refreshJwt: string;
+    handle: string;
+    did: string;
     [k: string]: unknown;
 }
-export declare type OutputSchema = ComAtprotoAdminDefs.ActionView;
 export interface HandlerInput {
     encoding: 'application/json';
     body: InputSchema;
@@ -24,6 +29,7 @@ export interface HandlerSuccess {
 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> = {

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/migrate-moderation-data.d.ts

@@ -0,0 +1 @@
+export declare function MigrateModerationData(): Promise<void>;

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>;
@@ -48,11 +49,8 @@ export declare class ActorViews {
         lists: ListInfoMap;
         labels: Labels;
         bam: BlockAndMuteState;
-    }, opts?: {
-        viewer?: string | null;
-    }): ProfileViewMap;
-    profileBasicPresentation(dids: string[], state: ProfileHydrationState, opts?: {
-        viewer?: string | null;
+    }, viewer: string | null): ProfileViewMap;
+    profileBasicPresentation(dids: string[], state: ProfileHydrationState, viewer: string | null, opts?: {
         omitLabels?: boolean;
     }): ProfileViewMap;
 }

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";
@@ -45,6 +47,7 @@ export declare class FeedService {
     getPostInfos(postUris: string[], viewer: string | null): Promise<PostInfoMap>;
     getFeedGeneratorInfos(generatorUris: string[], viewer: string | null): Promise<FeedGenInfoMap>;
     getFeedItems(uris: string[]): Promise<Record<string, FeedRow>>;
+    postUrisToFeedItems(uris: string[]): Promise<FeedRow[]>;
     feedItemRefs(items: FeedRow[]): {
         dids: Set<string>;
         uris: Set<string>;

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

@@ -5,6 +5,14 @@ export declare const invalidReplyRoot: (reply: ReplyRef, parent: {
     record: PostRecord;
     invalidReplyRoot: boolean | null;
 }) => boolean;
-export declare const violatesThreadGate: (db: DatabaseSchema, did: string, owner: string, root: PostRecord | null, gate: GateRecord | null) => Promise<boolean>;
+declare type ParsedThreadGate = {
+    canReply?: boolean;
+    allowMentions?: boolean;
+    allowFollowing?: boolean;
+    allowListUris?: string[];
+};
+export declare const parseThreadGate: (replierDid: string, ownerDid: string, rootPost: PostRecord | null, gate: GateRecord | null) => ParsedThreadGate;
+export declare const violatesThreadGate: (db: DatabaseSchema, replierDid: string, ownerDid: string, rootPost: PostRecord | null, gate: GateRecord | null) => Promise<boolean>;
 export declare const postToThreadgateUri: (postUri: string) => string;
 export declare const threadgateToPostUri: (gateUri: string) => string;
+export {};