@clioplaylists/clio 0.1.4 → 0.1.6

package/dist/index.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClioAppView = void 0;
+const common_1 = require("@atproto/common");
+const cors_1 = __importDefault(require("cors"));
+const dotenv_1 = require("dotenv");
+const events_1 = __importDefault(require("events"));
+const express_1 = __importDefault(require("express"));
+const http_terminator_1 = require("http-terminator");
+const api_1 = __importStar(require("./api"));
+const client_1 = require("./client");
+const context_1 = __importDefault(require("./context"));
+const error = __importStar(require("./error"));
+const lexicons_1 = require("./lexicons");
+const logger_1 = require("./logger");
+(0, dotenv_1.config)();
+class ClioAppView {
+    constructor(opts) {
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "app", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "terminator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ctx = opts.ctx;
+        this.app = opts.app;
+    }
+    static create(opts) {
+        const { config } = opts;
+        const app = (0, express_1.default)();
+        app.use((0, cors_1.default)({ maxAge: common_1.DAY / common_1.SECOND }));
+        app.use(logger_1.loggerMiddleware);
+        const dataplane = (0, client_1.createBaseClient)('http://localhost:4000', {});
+        const server = (0, lexicons_1.createServer)();
+        const ctx = new context_1.default({
+            cfg: config,
+            dataplane,
+        });
+        const api = (0, api_1.default)(server, ctx);
+        app.use(api_1.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 = (0, http_terminator_1.createHttpTerminator)({ server });
+        await events_1.default.once(server, 'listening');
+        const { port } = server.address();
+        this.ctx.cfg.assignPort(port);
+        return server;
+    }
+    async destroy() {
+        await this.terminator?.terminate();
+    }
+}
+exports.ClioAppView = ClioAppView;
+exports.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 {};