@clioplaylists/clio 0.1.5 → 0.1.7

package/dist/dataplane/server/routes/profile.js

@@ -0,0 +1,59 @@
+import { keyBy } from '@atproto/common';
+import { parseRecordBytes } from '../../../util';
+import { getRecords } from './records';
+export default (db) => ({
+    async getActors(req) {
+        const { dids } = req;
+        if (dids.length === 0) {
+            return { actors: [] };
+        }
+        const profileUris = dids.map((did) => `at://${did}/app.bsky.actor.profile/self`);
+        const chatDeclarationUris = dids.map((did) => `at://${did}/chat.bsky.actor.declaration/self`);
+        const [handlesRes, profiles, chatDeclarations] = await Promise.all([
+            db.db.selectFrom('actor').selectAll().execute(),
+            getRecords(db)({ uris: profileUris }),
+            getRecords(db)({ uris: chatDeclarationUris }),
+        ]);
+        const byDid = keyBy(handlesRes, 'did');
+        const actors = dids.map((did, i) => {
+            const row = byDid.get(did);
+            const chatDeclaration = parseRecordBytes(chatDeclarations.records[i].record);
+            return {
+                exists: !!row,
+                handle: row?.handle ?? undefined,
+                profile: profiles.records[i],
+                takenDown: !!row?.takedownRef,
+                takedownRef: row?.takedownRef || undefined,
+                tombstonedAt: undefined, // in current implementation, tombstoned actors are deleted
+                allowIncomingChatsFrom: typeof chatDeclaration?.['allowIncoming'] === 'string'
+                    ? chatDeclaration['allowIncoming']
+                    : undefined,
+                upstreamStatus: row?.upstreamStatus ?? '',
+                createdAt: profiles.records[i].createdAt, // @NOTE profile creation date not trusted in production
+            };
+        });
+        return { actors };
+    },
+    async getDidsByHandles(req) {
+        const { handles } = req;
+        if (handles.length === 0) {
+            return { dids: [] };
+        }
+        const res = await db.db
+            .selectFrom('actor')
+            .where('handle', 'in', handles)
+            .selectAll()
+            .execute();
+        const byHandle = keyBy(res, 'handle');
+        const dids = handles.map((handle) => byHandle.get(handle)?.did ?? '');
+        return { dids };
+    },
+    async updateActorUpstreamStatus(req) {
+        const { actorDid, upstreamStatus } = req;
+        await db.db
+            .updateTable('actor')
+            .set({ upstreamStatus })
+            .where('did', '=', actorDid)
+            .execute();
+    },
+});

package/dist/dataplane/server/routes/records.d.ts

@@ -0,0 +1,11 @@
+import { ServiceImpl } from '@connectrpc/connect';
+import { ClioService } from '../../../rpc/clio_connect';
+import { Record } from '../../../rpc/clio_pb';
+import { Database } from '../db';
+declare const _default: (db: Database) => Partial<ServiceImpl<typeof ClioService>>;
+export default _default;
+export declare const getRecords: (db: Database, collection?: string) => (req: {
+    uris: string[];
+}) => Promise<{
+    records: Record[];
+}>;

package/dist/dataplane/server/routes/records.js

@@ -0,0 +1,51 @@
+import { keyBy } from '@atproto/common';
+import { AtUri } from '@atproto/syntax';
+import { Timestamp } from '@bufbuild/protobuf';
+import * as ui8 from 'uint8arrays';
+import { ids } from '../../../lexicons/lexicons';
+import { Record } from '../../../rpc/clio_pb';
+export default (db) => ({
+    getProfileRecords: getRecords(db, ids.ComClioplaylistsAlphaActorProfile),
+});
+export const getRecords = (db, collection) => async (req) => {
+    const validUris = collection
+        ? req.uris.filter((uri) => new AtUri(uri).collection === collection)
+        : req.uris;
+    const res = validUris.length
+        ? await db.db
+            .selectFrom('record')
+            .selectAll()
+            .where('uri', 'in', validUris)
+            .execute()
+        : [];
+    const byUri = keyBy(res, 'uri');
+    const records = req.uris.map((uri) => {
+        const row = byUri.get(uri);
+        const json = row ? row.json : JSON.stringify(null);
+        const createdAtRaw = new Date(JSON.parse(json)?.['createdAt']);
+        const createdAt = !isNaN(createdAtRaw.getTime())
+            ? Timestamp.fromDate(createdAtRaw)
+            : undefined;
+        const indexedAt = row?.indexed_at
+            ? Timestamp.fromDate(new Date(row?.indexed_at))
+            : undefined;
+        const recordBytes = ui8.fromString(json, 'utf8');
+        return new Record({
+            record: recordBytes,
+            cid: row?.cid,
+            createdAt,
+            indexedAt,
+            sortedAt: compositeTime(createdAt, indexedAt),
+            takenDown: !!row?.takedown_ref,
+            takedownRef: row?.takedown_ref ?? undefined,
+        });
+    });
+    return { records };
+};
+const compositeTime = (ts1, ts2) => {
+    if (!ts1)
+        return ts2;
+    if (!ts2)
+        return ts1;
+    return ts1.toDate() < ts2.toDate() ? ts1 : ts2;
+};

package/dist/dataplane/server/routes/sync.d.ts

@@ -0,0 +1,5 @@
+import { ServiceImpl } from '@connectrpc/connect';
+import { ClioService } from '../../../rpc/clio_connect';
+import { Database } from '../db';
+declare const _default: (db: Database) => Partial<ServiceImpl<typeof ClioService>>;
+export default _default;

package/dist/dataplane/server/routes/sync.js

@@ -0,0 +1,12 @@
+export default (db) => ({
+    async getLatestRev(req) {
+        const res = await db.db
+            .selectFrom('actor_sync')
+            .where('did', '=', req.actorDid)
+            .select('repoRev')
+            .executeTakeFirst();
+        return {
+            rev: res?.repoRev ?? undefined,
+        };
+    },
+});

package/dist/dataplane/server/subscription.d.ts

@@ -0,0 +1,25 @@
+import { IdResolver } from '@atproto/identity';
+import { Firehose, MemoryRunner } from '@atproto/sync';
+import { BackgroundQueue } from './background';
+import { Database } from './db';
+import { IndexingService } from './indexing';
+export declare class RepoSubscription {
+    opts: {
+        service: string;
+        db: Database;
+        idResolver: IdResolver;
+    };
+    firehose: Firehose;
+    runner: MemoryRunner;
+    background: BackgroundQueue;
+    indexingSvc: IndexingService;
+    constructor(opts: {
+        service: string;
+        db: Database;
+        idResolver: IdResolver;
+    });
+    start(): void;
+    restart(): Promise<void>;
+    processAll(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/dataplane/server/subscription.js

@@ -0,0 +1,86 @@
+import { WriteOpAction } from '@atproto/repo';
+import { Firehose, MemoryRunner } from '@atproto/sync';
+import { subLogger as log } from '../../logger';
+import { BackgroundQueue } from './background';
+import { IndexingService } from './indexing';
+export class RepoSubscription {
+    opts;
+    firehose;
+    runner;
+    background;
+    indexingSvc;
+    constructor(opts) {
+        this.opts = opts;
+        const { service, db, idResolver } = opts;
+        this.background = new BackgroundQueue(db);
+        this.indexingSvc = new IndexingService(db, idResolver);
+        const { runner, firehose } = createFirehose({
+            idResolver,
+            service,
+            indexingSvc: this.indexingSvc,
+        });
+        this.runner = runner;
+        this.firehose = firehose;
+    }
+    start() {
+        this.firehose.start();
+    }
+    async restart() {
+        await this.destroy();
+        const { runner, firehose } = createFirehose({
+            idResolver: this.opts.idResolver,
+            service: this.opts.service,
+            indexingSvc: this.indexingSvc,
+        });
+        this.runner = runner;
+        this.firehose = firehose;
+        this.start();
+    }
+    async processAll() {
+        await this.runner.processAll();
+        await this.background.processAll();
+    }
+    async destroy() {
+        await this.firehose.destroy();
+        await this.runner.destroy();
+        await this.background.processAll();
+    }
+}
+const createFirehose = (opts) => {
+    const { idResolver, service, indexingSvc } = opts;
+    const runner = new MemoryRunner({ startCursor: 0 });
+    const firehose = new Firehose({
+        idResolver,
+        runner,
+        service,
+        unauthenticatedHandles: true, // indexing service handles these
+        unauthenticatedCommits: true, // @TODO there seems to be a very rare issue where the authenticator thinks a block is missing in deletion ops
+        onError: (err) => log.error({ err }, 'error in subscription'),
+        handleEvent: async (evt) => {
+            if (evt.event === 'identity') {
+                await indexingSvc.indexHandle(evt.did, evt.time, true);
+            }
+            else if (evt.event === 'account') {
+                if (evt.active === false && evt.status === 'deleted') {
+                    await indexingSvc.deleteActor(evt.did);
+                }
+                else {
+                    await indexingSvc.updateActorStatus(evt.did, evt.active, evt.status);
+                }
+            }
+            else {
+                const indexFn = evt.event === 'delete'
+                    ? indexingSvc.deleteRecord(evt.uri)
+                    : indexingSvc.indexRecord(evt.uri, evt.cid, evt.record, evt.event === 'create'
+                        ? WriteOpAction.Create
+                        : WriteOpAction.Update, evt.time);
+                await Promise.all([
+                    indexFn,
+                    indexingSvc.setCommitLastSeen(evt.did, evt.commit, evt.rev),
+                    indexingSvc.indexHandle(evt.did, evt.time),
+                ]);
+            }
+        },
+    });
+    return { firehose, runner };
+};

package/dist/error.d.ts

@@ -0,0 +1,2 @@
+import { ErrorRequestHandler } from 'express';
+export declare const handler: ErrorRequestHandler;

package/dist/error.js

@@ -0,0 +1,10 @@
+import { XRPCError } from '@atproto/xrpc-server';
+import { httpLogger as log } from './logger';
+export const handler = (err, _req, res, next) => {
+    log.error(err, 'unexpected internal server error');
+    if (res.headersSent) {
+        return next(err);
+    }
+    const serverError = XRPCError.fromError(err);
+    res.status(serverError.type).json(serverError.payload);
+};

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import express from 'express';
+import { Server } from 'http';
+import { ServerConfig } from './config';
+import AppContext from './context';
+export declare class ClioAppView {
+    ctx: AppContext;
+    app: express.Application;
+    server?: Server;
+    private terminator?;
+    constructor(opts: {
+        ctx: AppContext;
+        app: express.Application;
+    });
+    static create(opts: {
+        config: ServerConfig;
+    }): ClioAppView;
+    start(): Promise<Server>;
+    destroy(): Promise<void>;
+}
+export default ClioAppView;

package/dist/index.js

@@ -0,0 +1,55 @@
+import { DAY, SECOND } from '@atproto/common';
+import cors from 'cors';
+import { config } from 'dotenv';
+import events from 'events';
+import express from 'express';
+import { createHttpTerminator } from 'http-terminator';
+import API, { health } from './api';
+import { createBaseClient } from './client';
+import AppContext from './context';
+import * as error from './error';
+import { createServer } from './lexicons';
+import { loggerMiddleware } from './logger';
+config();
+export class ClioAppView {
+    ctx;
+    app;
+    server;
+    terminator;
+    constructor(opts) {
+        this.ctx = opts.ctx;
+        this.app = opts.app;
+    }
+    static create(opts) {
+        const { config } = opts;
+        const app = express();
+        app.use(cors({ maxAge: DAY / SECOND }));
+        app.use(loggerMiddleware);
+        const dataplane = createBaseClient('http://localhost:4000', {});
+        const server = createServer();
+        const ctx = new AppContext({
+            cfg: config,
+            dataplane,
+        });
+        const api = API(server, ctx);
+        app.use(health.createRouter(ctx));
+        app.use(api.xrpc.router);
+        app.use(error.handler);
+        return new ClioAppView({ ctx, app });
+    }
+    async start() {
+        console.log('Starting Clio AppView...');
+        const server = this.app.listen(this.ctx.cfg.port);
+        this.server = server;
+        server.keepAliveTimeout = 90000;
+        this.terminator = createHttpTerminator({ server });
+        await events.once(server, 'listening');
+        const { port } = server.address();
+        this.ctx.cfg.assignPort(port);
+        return server;
+    }
+    async destroy() {
+        await this.terminator?.terminate();
+    }
+}
+export default ClioAppView;

package/dist/lexicons/index.d.ts

@@ -0,0 +1,278 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { AuthVerifier, StreamAuthVerifier, Options as XrpcOptions, Server as XrpcServer } 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 ComAtprotoAdminEnableAccountInvites from './types/com/atproto/admin/enableAccountInvites';
+import * as ComAtprotoAdminGetAccountInfo from './types/com/atproto/admin/getAccountInfo';
+import * as ComAtprotoAdminGetAccountInfos from './types/com/atproto/admin/getAccountInfos';
+import * as ComAtprotoAdminGetInviteCodes from './types/com/atproto/admin/getInviteCodes';
+import * as ComAtprotoAdminGetSubjectStatus from './types/com/atproto/admin/getSubjectStatus';
+import * as ComAtprotoAdminSearchAccounts from './types/com/atproto/admin/searchAccounts';
+import * as ComAtprotoAdminSendEmail from './types/com/atproto/admin/sendEmail';
+import * as ComAtprotoAdminUpdateAccountEmail from './types/com/atproto/admin/updateAccountEmail';
+import * as ComAtprotoAdminUpdateAccountHandle from './types/com/atproto/admin/updateAccountHandle';
+import * as ComAtprotoAdminUpdateAccountPassword from './types/com/atproto/admin/updateAccountPassword';
+import * as ComAtprotoAdminUpdateSubjectStatus from './types/com/atproto/admin/updateSubjectStatus';
+import * as ComAtprotoIdentityGetRecommendedDidCredentials from './types/com/atproto/identity/getRecommendedDidCredentials';
+import * as ComAtprotoIdentityRefreshIdentity from './types/com/atproto/identity/refreshIdentity';
+import * as ComAtprotoIdentityRequestPlcOperationSignature from './types/com/atproto/identity/requestPlcOperationSignature';
+import * as ComAtprotoIdentityResolveDid from './types/com/atproto/identity/resolveDid';
+import * as ComAtprotoIdentityResolveHandle from './types/com/atproto/identity/resolveHandle';
+import * as ComAtprotoIdentityResolveIdentity from './types/com/atproto/identity/resolveIdentity';
+import * as ComAtprotoIdentitySignPlcOperation from './types/com/atproto/identity/signPlcOperation';
+import * as ComAtprotoIdentitySubmitPlcOperation from './types/com/atproto/identity/submitPlcOperation';
+import * as ComAtprotoIdentityUpdateHandle from './types/com/atproto/identity/updateHandle';
+import * as ComAtprotoLabelQueryLabels from './types/com/atproto/label/queryLabels';
+import * as ComAtprotoLabelSubscribeLabels from './types/com/atproto/label/subscribeLabels';
+import * as ComAtprotoModerationCreateReport from './types/com/atproto/moderation/createReport';
+import * as ComAtprotoRepoApplyWrites from './types/com/atproto/repo/applyWrites';
+import * as ComAtprotoRepoCreateRecord from './types/com/atproto/repo/createRecord';
+import * as ComAtprotoRepoDeleteRecord from './types/com/atproto/repo/deleteRecord';
+import * as ComAtprotoRepoDescribeRepo from './types/com/atproto/repo/describeRepo';
+import * as ComAtprotoRepoGetRecord from './types/com/atproto/repo/getRecord';
+import * as ComAtprotoRepoImportRepo from './types/com/atproto/repo/importRepo';
+import * as ComAtprotoRepoListMissingBlobs from './types/com/atproto/repo/listMissingBlobs';
+import * as ComAtprotoRepoListRecords from './types/com/atproto/repo/listRecords';
+import * as ComAtprotoRepoPutRecord from './types/com/atproto/repo/putRecord';
+import * as ComAtprotoRepoUploadBlob from './types/com/atproto/repo/uploadBlob';
+import * as ComAtprotoServerActivateAccount from './types/com/atproto/server/activateAccount';
+import * as ComAtprotoServerCheckAccountStatus from './types/com/atproto/server/checkAccountStatus';
+import * as ComAtprotoServerConfirmEmail from './types/com/atproto/server/confirmEmail';
+import * as ComAtprotoServerCreateAccount from './types/com/atproto/server/createAccount';
+import * as ComAtprotoServerCreateAppPassword from './types/com/atproto/server/createAppPassword';
+import * as ComAtprotoServerCreateInviteCode from './types/com/atproto/server/createInviteCode';
+import * as ComAtprotoServerCreateInviteCodes from './types/com/atproto/server/createInviteCodes';
+import * as ComAtprotoServerCreateSession from './types/com/atproto/server/createSession';
+import * as ComAtprotoServerDeactivateAccount from './types/com/atproto/server/deactivateAccount';
+import * as ComAtprotoServerDeleteAccount from './types/com/atproto/server/deleteAccount';
+import * as ComAtprotoServerDeleteSession from './types/com/atproto/server/deleteSession';
+import * as ComAtprotoServerDescribeServer from './types/com/atproto/server/describeServer';
+import * as ComAtprotoServerGetAccountInviteCodes from './types/com/atproto/server/getAccountInviteCodes';
+import * as ComAtprotoServerGetServiceAuth from './types/com/atproto/server/getServiceAuth';
+import * as ComAtprotoServerGetSession from './types/com/atproto/server/getSession';
+import * as ComAtprotoServerListAppPasswords from './types/com/atproto/server/listAppPasswords';
+import * as ComAtprotoServerRefreshSession from './types/com/atproto/server/refreshSession';
+import * as ComAtprotoServerRequestAccountDelete from './types/com/atproto/server/requestAccountDelete';
+import * as ComAtprotoServerRequestEmailConfirmation from './types/com/atproto/server/requestEmailConfirmation';
+import * as ComAtprotoServerRequestEmailUpdate from './types/com/atproto/server/requestEmailUpdate';
+import * as ComAtprotoServerRequestPasswordReset from './types/com/atproto/server/requestPasswordReset';
+import * as ComAtprotoServerReserveSigningKey from './types/com/atproto/server/reserveSigningKey';
+import * as ComAtprotoServerResetPassword from './types/com/atproto/server/resetPassword';
+import * as ComAtprotoServerRevokeAppPassword from './types/com/atproto/server/revokeAppPassword';
+import * as ComAtprotoServerUpdateEmail from './types/com/atproto/server/updateEmail';
+import * as ComAtprotoSyncGetBlob from './types/com/atproto/sync/getBlob';
+import * as ComAtprotoSyncGetBlocks from './types/com/atproto/sync/getBlocks';
+import * as ComAtprotoSyncGetCheckout from './types/com/atproto/sync/getCheckout';
+import * as ComAtprotoSyncGetHead from './types/com/atproto/sync/getHead';
+import * as ComAtprotoSyncGetLatestCommit from './types/com/atproto/sync/getLatestCommit';
+import * as ComAtprotoSyncGetRecord from './types/com/atproto/sync/getRecord';
+import * as ComAtprotoSyncGetRepo from './types/com/atproto/sync/getRepo';
+import * as ComAtprotoSyncGetRepoStatus from './types/com/atproto/sync/getRepoStatus';
+import * as ComAtprotoSyncListBlobs from './types/com/atproto/sync/listBlobs';
+import * as ComAtprotoSyncListRepos from './types/com/atproto/sync/listRepos';
+import * as ComAtprotoSyncListReposByCollection from './types/com/atproto/sync/listReposByCollection';
+import * as ComAtprotoSyncNotifyOfUpdate from './types/com/atproto/sync/notifyOfUpdate';
+import * as ComAtprotoSyncRequestCrawl from './types/com/atproto/sync/requestCrawl';
+import * as ComAtprotoSyncSubscribeRepos from './types/com/atproto/sync/subscribeRepos';
+import * as ComAtprotoTempAddReservedHandle from './types/com/atproto/temp/addReservedHandle';
+import * as ComAtprotoTempCheckSignupQueue from './types/com/atproto/temp/checkSignupQueue';
+import * as ComAtprotoTempFetchLabels from './types/com/atproto/temp/fetchLabels';
+import * as ComAtprotoTempRequestPhoneVerification from './types/com/atproto/temp/requestPhoneVerification';
+import * as ComClioplaylistsAlphaFeedGetSongs from './types/com/clioplaylists/alpha/feed/getSongs';
+export declare const COM_ATPROTO_MODERATION: {
+    DefsReasonSpam: string;
+    DefsReasonViolation: string;
+    DefsReasonMisleading: string;
+    DefsReasonSexual: string;
+    DefsReasonRude: string;
+    DefsReasonOther: string;
+    DefsReasonAppeal: string;
+};
+export declare function createServer(options?: XrpcOptions): Server;
+export declare class Server {
+    xrpc: XrpcServer;
+    com: ComNS;
+    constructor(options?: XrpcOptions);
+}
+export declare class ComNS {
+    _server: Server;
+    clioplaylists: ComClioplaylistsNS;
+    atproto: ComAtprotoNS;
+    constructor(server: Server);
+}
+export declare class ComClioplaylistsNS {
+    _server: Server;
+    alpha: ComClioplaylistsAlphaNS;
+    constructor(server: Server);
+}
+export declare class ComClioplaylistsAlphaNS {
+    _server: Server;
+    actor: ComClioplaylistsAlphaActorNS;
+    feed: ComClioplaylistsAlphaFeedNS;
+    constructor(server: Server);
+}
+export declare class ComClioplaylistsAlphaActorNS {
+    _server: Server;
+    constructor(server: Server);
+}
+export declare class ComClioplaylistsAlphaFeedNS {
+    _server: Server;
+    constructor(server: Server);
+    getSongs<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComClioplaylistsAlphaFeedGetSongs.Handler<ExtractAuth<AV>>, ComClioplaylistsAlphaFeedGetSongs.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoNS {
+    _server: Server;
+    admin: ComAtprotoAdminNS;
+    identity: ComAtprotoIdentityNS;
+    label: ComAtprotoLabelNS;
+    lexicon: ComAtprotoLexiconNS;
+    moderation: ComAtprotoModerationNS;
+    repo: ComAtprotoRepoNS;
+    server: ComAtprotoServerNS;
+    sync: ComAtprotoSyncNS;
+    temp: ComAtprotoTempNS;
+    constructor(server: Server);
+}
+export declare class ComAtprotoAdminNS {
+    _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;
+    enableAccountInvites<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminEnableAccountInvites.Handler<ExtractAuth<AV>>, ComAtprotoAdminEnableAccountInvites.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getAccountInfo<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminGetAccountInfo.Handler<ExtractAuth<AV>>, ComAtprotoAdminGetAccountInfo.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getAccountInfos<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminGetAccountInfos.Handler<ExtractAuth<AV>>, ComAtprotoAdminGetAccountInfos.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getInviteCodes<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminGetInviteCodes.Handler<ExtractAuth<AV>>, ComAtprotoAdminGetInviteCodes.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getSubjectStatus<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminGetSubjectStatus.Handler<ExtractAuth<AV>>, ComAtprotoAdminGetSubjectStatus.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    searchAccounts<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminSearchAccounts.Handler<ExtractAuth<AV>>, ComAtprotoAdminSearchAccounts.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    sendEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminSendEmail.Handler<ExtractAuth<AV>>, ComAtprotoAdminSendEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateAccountEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateAccountEmail.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateAccountEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateAccountHandle<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateAccountHandle.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateAccountHandle.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateAccountPassword<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateAccountPassword.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateAccountPassword.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateSubjectStatus<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoAdminUpdateSubjectStatus.Handler<ExtractAuth<AV>>, ComAtprotoAdminUpdateSubjectStatus.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoIdentityNS {
+    _server: Server;
+    constructor(server: Server);
+    getRecommendedDidCredentials<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentityGetRecommendedDidCredentials.Handler<ExtractAuth<AV>>, ComAtprotoIdentityGetRecommendedDidCredentials.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    refreshIdentity<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentityRefreshIdentity.Handler<ExtractAuth<AV>>, ComAtprotoIdentityRefreshIdentity.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestPlcOperationSignature<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentityRequestPlcOperationSignature.Handler<ExtractAuth<AV>>, ComAtprotoIdentityRequestPlcOperationSignature.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    resolveDid<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentityResolveDid.Handler<ExtractAuth<AV>>, ComAtprotoIdentityResolveDid.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    resolveHandle<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentityResolveHandle.Handler<ExtractAuth<AV>>, ComAtprotoIdentityResolveHandle.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    resolveIdentity<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentityResolveIdentity.Handler<ExtractAuth<AV>>, ComAtprotoIdentityResolveIdentity.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    signPlcOperation<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentitySignPlcOperation.Handler<ExtractAuth<AV>>, ComAtprotoIdentitySignPlcOperation.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    submitPlcOperation<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentitySubmitPlcOperation.Handler<ExtractAuth<AV>>, ComAtprotoIdentitySubmitPlcOperation.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateHandle<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoIdentityUpdateHandle.Handler<ExtractAuth<AV>>, ComAtprotoIdentityUpdateHandle.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoLabelNS {
+    _server: Server;
+    constructor(server: Server);
+    queryLabels<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoLabelQueryLabels.Handler<ExtractAuth<AV>>, ComAtprotoLabelQueryLabels.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    subscribeLabels<AV extends StreamAuthVerifier>(cfg: ConfigOf<AV, ComAtprotoLabelSubscribeLabels.Handler<ExtractAuth<AV>>, ComAtprotoLabelSubscribeLabels.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoLexiconNS {
+    _server: Server;
+    constructor(server: Server);
+}
+export declare class ComAtprotoModerationNS {
+    _server: Server;
+    constructor(server: Server);
+    createReport<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoModerationCreateReport.Handler<ExtractAuth<AV>>, ComAtprotoModerationCreateReport.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoRepoNS {
+    _server: Server;
+    constructor(server: Server);
+    applyWrites<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoApplyWrites.Handler<ExtractAuth<AV>>, ComAtprotoRepoApplyWrites.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    createRecord<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoCreateRecord.Handler<ExtractAuth<AV>>, ComAtprotoRepoCreateRecord.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    deleteRecord<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoDeleteRecord.Handler<ExtractAuth<AV>>, ComAtprotoRepoDeleteRecord.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    describeRepo<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoDescribeRepo.Handler<ExtractAuth<AV>>, ComAtprotoRepoDescribeRepo.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getRecord<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoGetRecord.Handler<ExtractAuth<AV>>, ComAtprotoRepoGetRecord.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    importRepo<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoImportRepo.Handler<ExtractAuth<AV>>, ComAtprotoRepoImportRepo.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    listMissingBlobs<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoListMissingBlobs.Handler<ExtractAuth<AV>>, ComAtprotoRepoListMissingBlobs.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    listRecords<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoListRecords.Handler<ExtractAuth<AV>>, ComAtprotoRepoListRecords.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    putRecord<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoPutRecord.Handler<ExtractAuth<AV>>, ComAtprotoRepoPutRecord.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    uploadBlob<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoRepoUploadBlob.Handler<ExtractAuth<AV>>, ComAtprotoRepoUploadBlob.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoServerNS {
+    _server: Server;
+    constructor(server: Server);
+    activateAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerActivateAccount.Handler<ExtractAuth<AV>>, ComAtprotoServerActivateAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    checkAccountStatus<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCheckAccountStatus.Handler<ExtractAuth<AV>>, ComAtprotoServerCheckAccountStatus.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    confirmEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerConfirmEmail.Handler<ExtractAuth<AV>>, ComAtprotoServerConfirmEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    createAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateAccount.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    createAppPassword<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateAppPassword.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateAppPassword.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    createInviteCode<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateInviteCode.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateInviteCode.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    createInviteCodes<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateInviteCodes.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateInviteCodes.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    createSession<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateSession.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateSession.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    deactivateAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerDeactivateAccount.Handler<ExtractAuth<AV>>, ComAtprotoServerDeactivateAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    deleteAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerDeleteAccount.Handler<ExtractAuth<AV>>, ComAtprotoServerDeleteAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    deleteSession<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerDeleteSession.Handler<ExtractAuth<AV>>, ComAtprotoServerDeleteSession.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    describeServer<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerDescribeServer.Handler<ExtractAuth<AV>>, ComAtprotoServerDescribeServer.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getAccountInviteCodes<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerGetAccountInviteCodes.Handler<ExtractAuth<AV>>, ComAtprotoServerGetAccountInviteCodes.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getServiceAuth<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerGetServiceAuth.Handler<ExtractAuth<AV>>, ComAtprotoServerGetServiceAuth.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getSession<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerGetSession.Handler<ExtractAuth<AV>>, ComAtprotoServerGetSession.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    listAppPasswords<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerListAppPasswords.Handler<ExtractAuth<AV>>, ComAtprotoServerListAppPasswords.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    refreshSession<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRefreshSession.Handler<ExtractAuth<AV>>, ComAtprotoServerRefreshSession.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestAccountDelete<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestAccountDelete.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestAccountDelete.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestEmailConfirmation<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestEmailConfirmation.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestEmailConfirmation.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestEmailUpdate<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestEmailUpdate.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestEmailUpdate.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestPasswordReset<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestPasswordReset.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestPasswordReset.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    reserveSigningKey<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerReserveSigningKey.Handler<ExtractAuth<AV>>, ComAtprotoServerReserveSigningKey.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    resetPassword<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerResetPassword.Handler<ExtractAuth<AV>>, ComAtprotoServerResetPassword.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    revokeAppPassword<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRevokeAppPassword.Handler<ExtractAuth<AV>>, ComAtprotoServerRevokeAppPassword.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerUpdateEmail.Handler<ExtractAuth<AV>>, ComAtprotoServerUpdateEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoSyncNS {
+    _server: Server;
+    constructor(server: Server);
+    getBlob<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetBlob.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetBlob.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getBlocks<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetBlocks.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetBlocks.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getCheckout<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetCheckout.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetCheckout.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getHead<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetHead.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetHead.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getLatestCommit<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetLatestCommit.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetLatestCommit.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getRecord<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetRecord.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetRecord.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getRepo<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetRepo.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetRepo.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    getRepoStatus<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncGetRepoStatus.Handler<ExtractAuth<AV>>, ComAtprotoSyncGetRepoStatus.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    listBlobs<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncListBlobs.Handler<ExtractAuth<AV>>, ComAtprotoSyncListBlobs.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    listRepos<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncListRepos.Handler<ExtractAuth<AV>>, ComAtprotoSyncListRepos.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    listReposByCollection<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncListReposByCollection.Handler<ExtractAuth<AV>>, ComAtprotoSyncListReposByCollection.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    notifyOfUpdate<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncNotifyOfUpdate.Handler<ExtractAuth<AV>>, ComAtprotoSyncNotifyOfUpdate.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestCrawl<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncRequestCrawl.Handler<ExtractAuth<AV>>, ComAtprotoSyncRequestCrawl.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    subscribeRepos<AV extends StreamAuthVerifier>(cfg: ConfigOf<AV, ComAtprotoSyncSubscribeRepos.Handler<ExtractAuth<AV>>, ComAtprotoSyncSubscribeRepos.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+export declare class ComAtprotoTempNS {
+    _server: Server;
+    constructor(server: Server);
+    addReservedHandle<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempAddReservedHandle.Handler<ExtractAuth<AV>>, ComAtprotoTempAddReservedHandle.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    checkSignupQueue<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempCheckSignupQueue.Handler<ExtractAuth<AV>>, ComAtprotoTempCheckSignupQueue.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    fetchLabels<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempFetchLabels.Handler<ExtractAuth<AV>>, ComAtprotoTempFetchLabels.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestPhoneVerification<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoTempRequestPhoneVerification.Handler<ExtractAuth<AV>>, ComAtprotoTempRequestPhoneVerification.HandlerReqCtx<ExtractAuth<AV>>>): void;
+}
+type SharedRateLimitOpts<T> = {
+    name: string;
+    calcKey?: (ctx: T) => string | null;
+    calcPoints?: (ctx: T) => number;
+};
+type RouteRateLimitOpts<T> = {
+    durationMs: number;
+    points: number;
+    calcKey?: (ctx: T) => string | null;
+    calcPoints?: (ctx: T) => number;
+};
+type HandlerOpts = {
+    blobLimit?: number;
+};
+type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>;
+type ConfigOf<Auth, Handler, ReqCtx> = Handler | {
+    auth?: Auth;
+    opts?: HandlerOpts;
+    rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[];
+    handler: Handler;
+};
+type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract<Awaited<ReturnType<AV>>, {
+    credentials: unknown;
+}>;
+export {};