@atproto/ozone 0.0.2

package/dist/lexicon/types/com/atproto/sync/subscribeRepos.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node/http" />
+/// <reference types="pino-http" />
+import { ValidationResult } from '@atproto/lexicon';
+import { CID } from 'multiformats/cid';
+import { HandlerAuth, ErrorFrame } from '@atproto/xrpc-server';
+import { IncomingMessage } from 'http';
+export interface QueryParams {
+    cursor?: number;
+}
+export type OutputSchema = Commit | Handle | Migrate | Tombstone | Info | {
+    $type: string;
+    [k: string]: unknown;
+};
+export type HandlerError = ErrorFrame<'FutureCursor' | 'ConsumerTooSlow'>;
+export type HandlerOutput = HandlerError | OutputSchema;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    req: IncomingMessage;
+    signal: AbortSignal;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => AsyncIterable<HandlerOutput>;
+export interface Commit {
+    seq: number;
+    rebase: boolean;
+    tooBig: boolean;
+    repo: string;
+    commit: CID;
+    prev?: CID | null;
+    rev: string;
+    since: string | null;
+    blocks: Uint8Array;
+    ops: RepoOp[];
+    blobs: CID[];
+    time: string;
+    [k: string]: unknown;
+}
+export declare function isCommit(v: unknown): v is Commit;
+export declare function validateCommit(v: unknown): ValidationResult;
+export interface Handle {
+    seq: number;
+    did: string;
+    handle: string;
+    time: string;
+    [k: string]: unknown;
+}
+export declare function isHandle(v: unknown): v is Handle;
+export declare function validateHandle(v: unknown): ValidationResult;
+export interface Migrate {
+    seq: number;
+    did: string;
+    migrateTo: string | null;
+    time: string;
+    [k: string]: unknown;
+}
+export declare function isMigrate(v: unknown): v is Migrate;
+export declare function validateMigrate(v: unknown): ValidationResult;
+export interface Tombstone {
+    seq: number;
+    did: string;
+    time: string;
+    [k: string]: unknown;
+}
+export declare function isTombstone(v: unknown): v is Tombstone;
+export declare function validateTombstone(v: unknown): ValidationResult;
+export interface Info {
+    name: 'OutdatedCursor' | (string & {});
+    message?: string;
+    [k: string]: unknown;
+}
+export declare function isInfo(v: unknown): v is Info;
+export declare function validateInfo(v: unknown): ValidationResult;
+export interface RepoOp {
+    action: 'create' | 'update' | 'delete' | (string & {});
+    path: string;
+    cid: CID | null;
+    [k: string]: unknown;
+}
+export declare function isRepoOp(v: unknown): v is RepoOp;
+export declare function validateRepoOp(v: unknown): ValidationResult;

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

@@ -0,0 +1,33 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+import * as ComAtprotoLabelDefs from '../label/defs';
+export interface QueryParams {
+    since?: number;
+    limit: number;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    labels: ComAtprotoLabelDefs.Label[];
+    [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;

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 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 type HandlerOutput = HandlerError | HandlerSuccess;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/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 type InputSchema = string | Uint8Array;
+export interface HandlerInput {
+    encoding: '*/*';
+    body: stream.Readable;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export type HandlerOutput = HandlerError | void;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

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

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

package/dist/lexicon/types/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 type HandlerOutput = HandlerError | HandlerSuccess;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/util.d.ts

@@ -0,0 +1,2 @@
+export declare function isObj(v: unknown): v is Record<string, unknown>;
+export declare function hasProp<K extends PropertyKey>(data: object, prop: K): data is Record<K, unknown>;

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+import { subsystemLogger } from '@atproto/common';
+export declare const dbLogger: ReturnType<typeof subsystemLogger>;
+export declare const httpLogger: ReturnType<typeof subsystemLogger>;
+export declare const loggerMiddleware: import("pino-http").HttpLogger;

package/dist/mod-service/index.d.ts

@@ -0,0 +1,155 @@
+import { CID } from 'multiformats/cid';
+import { AtUri } from '@atproto/syntax';
+import { Database } from '../db';
+import { AppviewAuth, ModerationViews } from './views';
+import { Main as StrongRef } from '../lexicon/types/com/atproto/repo/strongRef';
+import { RepoRef, RepoBlobRef } from '../lexicon/types/com/atproto/admin/defs';
+import { ModEventType, ModerationEventRow, ModerationSubjectStatusRow, ReversibleModerationEvent } from './types';
+import { ModerationEvent } from '../db/schema/moderation_event';
+import AtpAgent from '@atproto/api';
+import { Label } from '../lexicon/types/com/atproto/label/defs';
+import { ModSubject, RecordSubject, RepoSubject } from './subject';
+import { BackgroundQueue } from '../background';
+import { EventPusher } from '../daemon';
+export type ModerationServiceCreator = (db: Database) => ModerationService;
+export declare class ModerationService {
+    db: Database;
+    backgroundQueue: BackgroundQueue;
+    eventPusher: EventPusher;
+    appviewAgent: AtpAgent;
+    private appviewAuth;
+    constructor(db: Database, backgroundQueue: BackgroundQueue, eventPusher: EventPusher, appviewAgent: AtpAgent, appviewAuth: AppviewAuth);
+    static creator(backgroundQueue: BackgroundQueue, eventPusher: EventPusher, appviewAgent: AtpAgent, appviewAuth: AppviewAuth): (db: Database) => ModerationService;
+    views: ModerationViews;
+    getEvent(id: number): Promise<ModerationEventRow | undefined>;
+    getEventOrThrow(id: number): Promise<ModerationEventRow>;
+    getEvents(opts: {
+        subject?: string;
+        createdBy?: string;
+        limit: number;
+        cursor?: string;
+        includeAllUserRecords: boolean;
+        types: ModerationEvent['action'][];
+        sortDirection?: 'asc' | 'desc';
+    }): Promise<{
+        cursor?: string;
+        events: ModerationEventRow[];
+    }>;
+    getReport(id: number): Promise<ModerationEventRow | undefined>;
+    getCurrentStatus(subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+    } | {
+        cids: CID[];
+    }): Promise<{
+        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;
+        lastAppealedAt: string | null;
+        takendown: boolean;
+        appealed: boolean | null;
+        suspendUntil: string | null;
+        recordPath: string;
+        recordCid: string | null;
+    }[]>;
+    logEvent(info: {
+        event: ModEventType;
+        subject: ModSubject;
+        createdBy: string;
+        createdAt?: Date;
+    }): Promise<ModerationEventRow>;
+    getLastReversibleEventForSubject(subject: ReversalSubject): 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#modEventAcknowledge" | "com.atproto.admin.defs#modEventEscalate" | "com.atproto.admin.defs#modEventComment" | "com.atproto.admin.defs#modEventLabel" | "com.atproto.admin.defs#modEventReport" | "com.atproto.admin.defs#modEventMute" | "com.atproto.admin.defs#modEventReverseTakedown" | "com.atproto.admin.defs#modEventEmail" | "com.atproto.admin.defs#modEventResolveAppeal";
+        subjectType: "com.atproto.admin.defs#repoRef" | "com.atproto.repo.strongRef";
+        subjectDid: string;
+        subjectUri: string | null;
+        subjectCid: string | null;
+        meta: Record<string, string | boolean> | null;
+        expiresAt: string | null;
+        legacyRefId: number | null;
+    } | null | undefined>;
+    getSubjectsDueForReversal(): Promise<ReversalSubject[]>;
+    isSubjectSuspended(did: string): Promise<boolean>;
+    revertState({ createdBy, createdAt, comment, action, subject, }: ReversibleModerationEvent): Promise<ModerationEventRow>;
+    takedownRepo(subject: RepoSubject, takedownId: number, isSuspend?: boolean): Promise<void>;
+    reverseTakedownRepo(subject: RepoSubject): Promise<void>;
+    takedownRecord(subject: RecordSubject, takedownId: number): Promise<void>;
+    reverseTakedownRecord(subject: RecordSubject): Promise<void>;
+    report(info: {
+        reasonType: NonNullable<ModerationEventRow['meta']>['reportType'];
+        reason?: string;
+        subject: ModSubject;
+        reportedBy: string;
+        createdAt?: Date;
+    }): Promise<ModerationEventRow>;
+    getSubjectStatuses({ cursor, limit, takendown, appealed, reviewState, reviewedAfter, reviewedBefore, reportedAfter, reportedBefore, includeMuted, ignoreSubjects, sortDirection, lastReviewedBy, sortField, subject, }: {
+        cursor?: string;
+        limit?: number;
+        takendown?: boolean;
+        appealed?: boolean | null;
+        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: {
+            handle: string;
+            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;
+            lastAppealedAt: string | null;
+            takendown: boolean;
+            appealed: boolean | null;
+            suspendUntil: string | null;
+            recordPath: string;
+            recordCid: string | null;
+        }[];
+        cursor: string | undefined;
+    }>;
+    isSubjectTakendown(subject: ModSubject): Promise<boolean>;
+    formatAndCreateLabels(src: string, uri: string, cid: string | null, labels: {
+        create?: string[];
+        negate?: string[];
+    }): Promise<Label[]>;
+    createLabels(labels: Label[]): Promise<void>;
+}
+export type TakedownSubjects = {
+    did: string;
+    subjects: (RepoRef | RepoBlobRef | StrongRef)[];
+};
+export type ReversalSubject = {
+    subject: ModSubject;
+    reverseSuspend: boolean;
+    reverseMute: boolean;
+};

package/dist/mod-service/status.d.ts

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

package/dist/mod-service/subject.d.ts

@@ -0,0 +1,59 @@
+import { AtUri } from '@atproto/syntax';
+import { InputSchema as ReportInput } from '../lexicon/types/com/atproto/moderation/createReport';
+import { InputSchema as ActionInput } from '../lexicon/types/com/atproto/admin/emitModerationEvent';
+import { ModerationEventRow, ModerationSubjectStatusRow } from './types';
+import { RepoRef } from '../lexicon/types/com/atproto/admin/defs';
+import { Main as StrongRef } from '../lexicon/types/com/atproto/repo/strongRef';
+type SubjectInput = ReportInput['subject'] | ActionInput['subject'];
+export declare const subjectFromInput: (subject: SubjectInput, blobs?: string[]) => ModSubject;
+export declare const subjectFromEventRow: (row: ModerationEventRow) => ModSubject;
+export declare const subjectFromStatusRow: (row: ModerationSubjectStatusRow) => ModSubject;
+type SubjectInfo = {
+    subjectType: 'com.atproto.admin.defs#repoRef' | 'com.atproto.repo.strongRef';
+    subjectDid: string;
+    subjectUri: string | null;
+    subjectCid: string | null;
+};
+export interface ModSubject {
+    did: string;
+    recordPath: string | undefined;
+    blobCids?: string[];
+    isRepo(): this is RepoSubject;
+    isRecord(): this is RecordSubject;
+    info(): SubjectInfo;
+    lex(): RepoRef | StrongRef;
+}
+export declare class RepoSubject implements ModSubject {
+    did: string;
+    blobCids: undefined;
+    recordPath: undefined;
+    constructor(did: string);
+    isRepo(): boolean;
+    isRecord(): boolean;
+    info(): {
+        subjectType: "com.atproto.admin.defs#repoRef";
+        subjectDid: string;
+        subjectUri: null;
+        subjectCid: null;
+    };
+    lex(): RepoRef;
+}
+export declare class RecordSubject implements ModSubject {
+    uri: string;
+    cid: string;
+    blobCids?: string[] | undefined;
+    parsedUri: AtUri;
+    did: string;
+    recordPath: string;
+    constructor(uri: string, cid: string, blobCids?: string[] | undefined);
+    isRepo(): boolean;
+    isRecord(): boolean;
+    info(): {
+        subjectType: "com.atproto.repo.strongRef";
+        subjectDid: string;
+        subjectUri: string;
+        subjectCid: string;
+    };
+    lex(): StrongRef;
+}
+export {};

package/dist/mod-service/types.d.ts

@@ -0,0 +1,19 @@
+import { Selectable } from 'kysely';
+import { ModerationEvent } from '../db/schema/moderation_event';
+import { ModerationSubjectStatus } from '../db/schema/moderation_subject_status';
+import { ComAtprotoAdminDefs } from '@atproto/api';
+import { ModSubject } from './subject';
+export type ModerationEventRow = Selectable<ModerationEvent>;
+export type ReversibleModerationEvent = Pick<ModerationEventRow, 'createdBy' | 'comment' | 'action'> & {
+    createdAt?: Date;
+    subject: ModSubject;
+};
+export type ModerationEventRowWithHandle = ModerationEventRow & {
+    subjectHandle?: string | null;
+    creatorHandle?: string | null;
+};
+export type ModerationSubjectStatusRow = Selectable<ModerationSubjectStatus>;
+export type ModerationSubjectStatusRowWithHandle = ModerationSubjectStatusRow & {
+    handle: string | null;
+};
+export type ModEventType = ComAtprotoAdminDefs.ModEventTakedown | ComAtprotoAdminDefs.ModEventAcknowledge | ComAtprotoAdminDefs.ModEventEscalate | ComAtprotoAdminDefs.ModEventComment | ComAtprotoAdminDefs.ModEventLabel | ComAtprotoAdminDefs.ModEventReport | ComAtprotoAdminDefs.ModEventMute | ComAtprotoAdminDefs.ModEventReverseTakedown;

package/dist/mod-service/views.d.ts

@@ -0,0 +1,49 @@
+import AtpAgent from '@atproto/api';
+import { BlobRef } from '@atproto/lexicon';
+import { Database } from '../db';
+import { ModEventView, RepoView, RepoViewDetail, RecordView, RecordViewDetail, ReportViewDetail, BlobView, SubjectStatusView, ModEventViewDetail, AccountView } 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 { ModerationEventRowWithHandle, ModerationSubjectStatusRowWithHandle } from './types';
+export type AppviewAuth = () => Promise<{
+    headers: {
+        authorization: string;
+    };
+} | undefined>;
+export declare class ModerationViews {
+    private db;
+    private appviewAgent;
+    private appviewAuth;
+    constructor(db: Database, appviewAgent: AtpAgent, appviewAuth: AppviewAuth);
+    getAccoutInfosByDid(dids: string[]): Promise<Map<string, AccountView>>;
+    repos(dids: string[]): Promise<Map<string, RepoView>>;
+    formatEvent(event: ModerationEventRowWithHandle): ModEventView;
+    eventDetail(result: ModerationEventRowWithHandle): Promise<ModEventViewDetail>;
+    repoDetail(did: string): Promise<RepoViewDetail | undefined>;
+    fetchRecords(subjects: RecordSubject[]): Promise<Map<string, RecordInfo>>;
+    records(subjects: RecordSubject[]): Promise<Map<string, RecordView>>;
+    recordDetail(subject: RecordSubject): Promise<RecordViewDetail | undefined>;
+    formatReport(report: ModerationEventRowWithHandle): ReportOutput;
+    subject(subject: string): Promise<SubjectView>;
+    blob(blobs: BlobRef[]): Promise<BlobView[]>;
+    labels(subject: string, includeNeg?: boolean): Promise<Label[]>;
+    getSubjectStatus(subjects: string[]): Promise<Map<string, ModerationSubjectStatusRowWithHandle>>;
+    formatSubjectStatus(status: ModerationSubjectStatusRowWithHandle): SubjectStatusView;
+}
+type RecordSubject = {
+    uri: string;
+    cid?: string;
+};
+type SubjectView = ModEventViewDetail['subject'] & ReportViewDetail['subject'];
+type RecordInfo = {
+    uri: string;
+    cid: string;
+    value: Record<string, unknown>;
+    indexedAt: string;
+};
+export declare function getSelfLabels(details: {
+    uri: string | null;
+    cid: string | null;
+    record: Record<string, unknown> | null;
+}): Label[];
+export {};

package/dist/sequencer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sequencer';
+export * from './outbox';

package/dist/sequencer/outbox.d.ts

@@ -0,0 +1,16 @@
+import { AsyncBuffer } from '@atproto/common';
+import { Sequencer, LabelsEvt } from './sequencer';
+export type OutboxOpts = {
+    maxBufferSize: number;
+};
+export declare class Outbox {
+    sequencer: Sequencer;
+    private caughtUp;
+    lastSeen: number;
+    cutoverBuffer: LabelsEvt[];
+    outBuffer: AsyncBuffer<LabelsEvt>;
+    constructor(sequencer: Sequencer, opts?: Partial<OutboxOpts>);
+    events(backfillCursor?: number, signal?: AbortSignal): AsyncGenerator<LabelsEvt>;
+    getBackfill(backfillCursor: number): AsyncGenerator<LabelsEvt, void, unknown>;
+}
+export default Outbox;

package/dist/sequencer/sequencer.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import TypedEmitter from 'typed-emitter';
+import Database from '../db';
+import { Labels as LabelsEvt } from '../lexicon/types/com/atproto/label/subscribeLabels';
+import { Label as LabelTable } from '../db/schema/label';
+import { Selectable } from 'kysely';
+import { ModerationService } from '../mod-service';
+export type { Labels as LabelsEvt } from '../lexicon/types/com/atproto/label/subscribeLabels';
+type LabelRow = Selectable<LabelTable>;
+declare const Sequencer_base: new () => SequencerEmitter;
+export declare class Sequencer extends Sequencer_base {
+    modService: ModerationService;
+    lastSeen: number;
+    destroyed: boolean;
+    pollPromise: Promise<void>;
+    pollTimer: NodeJS.Timer | undefined;
+    triesWithNoResults: number;
+    db: Database;
+    constructor(modService: ModerationService, lastSeen?: number);
+    start(): Promise<void>;
+    destroy(): Promise<void>;
+    curr(): Promise<number | null>;
+    next(cursor: number): Promise<LabelRow | null>;
+    requestLabelRange(opts: {
+        earliestId?: number;
+        limit?: number;
+    }): Promise<LabelsEvt[]>;
+    private poll;
+}
+type SequencerEvents = {
+    events: (evts: LabelsEvt[]) => void;
+    close: () => void;
+};
+export type SequencerEmitter = TypedEmitter<SequencerEvents>;
+export default Sequencer;

package/dist/services/index.d.ts

@@ -0,0 +1,7 @@
+import AtpAgent from '@atproto/api';
+import { ModerationService } from './moderation';
+import { FromDb } from './types';
+export declare function createServices(appviewAgent: AtpAgent): Services;
+export declare type Services = {
+    moderation: FromDb<ModerationService>;
+};