@clioplaylists/clio 0.1.0 → 0.1.1

package/dist/lexicons/types/com/atproto/identity/resolveDid.d.ts

@@ -0,0 +1,38 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+    /** DID to resolve. */
+    did: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    /** The complete DID document for the identity. */
+    didDoc: {};
+    [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;
+    error?: 'DidNotFound' | 'DidDeactivated';
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/identity/resolveHandle.d.ts

@@ -0,0 +1,37 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+    /** The handle to resolve. */
+    handle: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    did: string;
+    [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;
+    error?: 'HandleNotFound';
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/identity/resolveIdentity.d.ts

@@ -0,0 +1,35 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+import * as ComAtprotoIdentityDefs from './defs';
+export interface QueryParams {
+    /** Handle or DID to resolve. */
+    identifier: string;
+}
+export type InputSchema = undefined;
+export type OutputSchema = ComAtprotoIdentityDefs.IdentityInfo;
+export type HandlerInput = undefined;
+export interface HandlerSuccess {
+    encoding: 'application/json';
+    body: OutputSchema;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+    error?: 'HandleNotFound' | 'DidNotFound' | 'DidDeactivated';
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/identity/signPlcOperation.d.ts

@@ -0,0 +1,46 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    /** A token received through com.atproto.identity.requestPlcOperationSignature */
+    token?: string;
+    rotationKeys?: string[];
+    alsoKnownAs?: string[];
+    verificationMethods?: {};
+    services?: {};
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    /** A signed DID PLC operation. */
+    operation: {};
+    [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;
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/identity/submitPlcOperation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    operation: {};
+    [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;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/identity/updateHandle.d.ts

@@ -0,0 +1,30 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    /** The new handle. */
+    handle: 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;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/label/defs.d.ts

@@ -0,0 +1,73 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+/** Metadata tag on an atproto resource (eg, repo or record). */
+export interface Label {
+    /** The AT Protocol version of the label object. */
+    ver?: number;
+    /** DID of the actor who created this label. */
+    src: string;
+    /** AT URI of the record, repository (account), or other resource that this label applies to. */
+    uri: string;
+    /** Optionally, CID specifying the specific version of 'uri' resource this label applies to. */
+    cid?: string;
+    /** The short string name of the value or type of this label. */
+    val: string;
+    /** If true, this is a negation label, overwriting a previous label. */
+    neg?: boolean;
+    /** Timestamp when this label was created. */
+    cts: string;
+    /** Timestamp at which this label expires (no longer applies). */
+    exp?: string;
+    /** Signature of dag-cbor encoded label. */
+    sig?: Uint8Array;
+    [k: string]: unknown;
+}
+export declare function isLabel(v: unknown): v is Label;
+export declare function validateLabel(v: unknown): ValidationResult;
+/** Metadata tags on an atproto record, published by the author within the record. */
+export interface SelfLabels {
+    values: SelfLabel[];
+    [k: string]: unknown;
+}
+export declare function isSelfLabels(v: unknown): v is SelfLabels;
+export declare function validateSelfLabels(v: unknown): ValidationResult;
+/** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. */
+export interface SelfLabel {
+    /** The short string name of the value or type of this label. */
+    val: string;
+    [k: string]: unknown;
+}
+export declare function isSelfLabel(v: unknown): v is SelfLabel;
+export declare function validateSelfLabel(v: unknown): ValidationResult;
+/** Declares a label value and its expected interpretations and behaviors. */
+export interface LabelValueDefinition {
+    /** The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). */
+    identifier: string;
+    /** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */
+    severity: 'inform' | 'alert' | 'none' | (string & {});
+    /** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. */
+    blurs: 'content' | 'media' | 'none' | (string & {});
+    /** The default setting for this label. */
+    defaultSetting: 'ignore' | 'warn' | 'hide' | (string & {});
+    /** Does the user need to have adult content enabled in order to configure this label? */
+    adultOnly?: boolean;
+    locales: LabelValueDefinitionStrings[];
+    [k: string]: unknown;
+}
+export declare function isLabelValueDefinition(v: unknown): v is LabelValueDefinition;
+export declare function validateLabelValueDefinition(v: unknown): ValidationResult;
+/** Strings which describe the label in the UI, localized into a specific language. */
+export interface LabelValueDefinitionStrings {
+    /** The code of the language these strings are written in. */
+    lang: string;
+    /** A short human-readable name for the label. */
+    name: string;
+    /** A longer description of what the label means and why it might be applied. */
+    description: string;
+    [k: string]: unknown;
+}
+export declare function isLabelValueDefinitionStrings(v: unknown): v is LabelValueDefinitionStrings;
+export declare function validateLabelValueDefinitionStrings(v: unknown): ValidationResult;
+export type LabelValue = '!hide' | '!no-promote' | '!warn' | '!no-unauthenticated' | 'dmca-violation' | 'doxxing' | 'porn' | 'sexual' | 'nudity' | 'nsfl' | 'gore' | (string & {});

package/dist/lexicons/types/com/atproto/label/queryLabels.d.ts

@@ -0,0 +1,42 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+import * as ComAtprotoLabelDefs from './defs';
+export interface QueryParams {
+    /** List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI. */
+    uriPatterns: string[];
+    /** Optional list of label sources (DIDs) to filter on. */
+    sources?: string[];
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    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 | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/label/subscribeLabels.d.ts

@@ -0,0 +1,38 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+import { ErrorFrame, HandlerAuth } from '@atproto/xrpc-server';
+import { IncomingMessage } from 'http';
+import * as ComAtprotoLabelDefs from './defs';
+export interface QueryParams {
+    /** The last known event seq number to backfill from. */
+    cursor?: number;
+}
+export type OutputSchema = Labels | Info | {
+    $type: string;
+    [k: string]: unknown;
+};
+export type HandlerError = ErrorFrame<'FutureCursor'>;
+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 Labels {
+    seq: number;
+    labels: ComAtprotoLabelDefs.Label[];
+    [k: string]: unknown;
+}
+export declare function isLabels(v: unknown): v is Labels;
+export declare function validateLabels(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;

package/dist/lexicons/types/com/atproto/lexicon/schema.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+export interface Record {
+    /** Indicates the 'version' of the Lexicon language. Must be '1' for the current atproto/Lexicon schema system. */
+    lexicon: number;
+    [k: string]: unknown;
+}
+export declare function isRecord(v: unknown): v is Record;
+export declare function validateRecord(v: unknown): ValidationResult;

package/dist/lexicons/types/com/atproto/moderation/createReport.d.ts

@@ -0,0 +1,57 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+import * as ComAtprotoAdminDefs from '../admin/defs';
+import * as ComAtprotoRepoStrongRef from '../repo/strongRef';
+import * as ComAtprotoModerationDefs from './defs';
+export interface QueryParams {
+}
+export interface InputSchema {
+    reasonType: ComAtprotoModerationDefs.ReasonType;
+    /** Additional context about the content and violation. */
+    reason?: string;
+    subject: ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main | {
+        $type: string;
+        [k: string]: unknown;
+    };
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    id: number;
+    reasonType: ComAtprotoModerationDefs.ReasonType;
+    reason?: string;
+    subject: ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main | {
+        $type: string;
+        [k: string]: unknown;
+    };
+    reportedBy: string;
+    createdAt: 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;
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/moderation/defs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+export type ReasonType = 'com.atproto.moderation.defs#reasonSpam' | 'com.atproto.moderation.defs#reasonViolation' | 'com.atproto.moderation.defs#reasonMisleading' | 'com.atproto.moderation.defs#reasonSexual' | 'com.atproto.moderation.defs#reasonRude' | 'com.atproto.moderation.defs#reasonOther' | 'com.atproto.moderation.defs#reasonAppeal' | (string & {});
+/** Spam: frequent unwanted promotion, replies, mentions */
+export declare const REASONSPAM = "com.atproto.moderation.defs#reasonSpam";
+/** Direct violation of server rules, laws, terms of service */
+export declare const REASONVIOLATION = "com.atproto.moderation.defs#reasonViolation";
+/** Misleading identity, affiliation, or content */
+export declare const REASONMISLEADING = "com.atproto.moderation.defs#reasonMisleading";
+/** Unwanted or mislabeled sexual content */
+export declare const REASONSEXUAL = "com.atproto.moderation.defs#reasonSexual";
+/** Rude, harassing, explicit, or otherwise unwelcoming behavior */
+export declare const REASONRUDE = "com.atproto.moderation.defs#reasonRude";
+/** Other: reports not falling under another report category */
+export declare const REASONOTHER = "com.atproto.moderation.defs#reasonOther";
+/** Appeal: appeal a previously taken moderation action */
+export declare const REASONAPPEAL = "com.atproto.moderation.defs#reasonAppeal";
+/** Tag describing a type of subject that might be reported. */
+export type SubjectType = 'account' | 'record' | 'chat' | (string & {});

package/dist/lexicons/types/com/atproto/repo/applyWrites.d.ts

@@ -0,0 +1,98 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+import * as ComAtprotoRepoDefs from './defs';
+export interface QueryParams {
+}
+export interface InputSchema {
+    /** The handle or DID of the repo (aka, current account). */
+    repo: string;
+    /** Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons. */
+    validate?: boolean;
+    writes: (Create | Update | Delete)[];
+    /** If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations. */
+    swapCommit?: string;
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    commit?: ComAtprotoRepoDefs.CommitMeta;
+    results?: (CreateResult | UpdateResult | DeleteResult)[];
+    [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?: 'InvalidSwap';
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;
+/** Operation which creates a new record. */
+export interface Create {
+    collection: string;
+    /** NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility. */
+    rkey?: string;
+    value: {};
+    [k: string]: unknown;
+}
+export declare function isCreate(v: unknown): v is Create;
+export declare function validateCreate(v: unknown): ValidationResult;
+/** Operation which updates an existing record. */
+export interface Update {
+    collection: string;
+    rkey: string;
+    value: {};
+    [k: string]: unknown;
+}
+export declare function isUpdate(v: unknown): v is Update;
+export declare function validateUpdate(v: unknown): ValidationResult;
+/** Operation which deletes an existing record. */
+export interface Delete {
+    collection: string;
+    rkey: string;
+    [k: string]: unknown;
+}
+export declare function isDelete(v: unknown): v is Delete;
+export declare function validateDelete(v: unknown): ValidationResult;
+export interface CreateResult {
+    uri: string;
+    cid: string;
+    validationStatus?: 'valid' | 'unknown' | (string & {});
+    [k: string]: unknown;
+}
+export declare function isCreateResult(v: unknown): v is CreateResult;
+export declare function validateCreateResult(v: unknown): ValidationResult;
+export interface UpdateResult {
+    uri: string;
+    cid: string;
+    validationStatus?: 'valid' | 'unknown' | (string & {});
+    [k: string]: unknown;
+}
+export declare function isUpdateResult(v: unknown): v is UpdateResult;
+export declare function validateUpdateResult(v: unknown): ValidationResult;
+export interface DeleteResult {
+    [k: string]: unknown;
+}
+export declare function isDeleteResult(v: unknown): v is DeleteResult;
+export declare function validateDeleteResult(v: unknown): ValidationResult;

package/dist/lexicons/types/com/atproto/repo/createRecord.d.ts

@@ -0,0 +1,56 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+import * as ComAtprotoRepoDefs from './defs';
+export interface QueryParams {
+}
+export interface InputSchema {
+    /** The handle or DID of the repo (aka, current account). */
+    repo: string;
+    /** The NSID of the record collection. */
+    collection: string;
+    /** The Record Key. */
+    rkey?: string;
+    /** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. */
+    validate?: boolean;
+    /** The record itself. Must contain a $type field. */
+    record: {};
+    /** Compare and swap with the previous commit by CID. */
+    swapCommit?: string;
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    uri: string;
+    cid: string;
+    commit?: ComAtprotoRepoDefs.CommitMeta;
+    validationStatus?: 'valid' | 'unknown' | (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?: 'InvalidSwap';
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicons/types/com/atproto/repo/defs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+export interface CommitMeta {
+    cid: string;
+    rev: string;
+    [k: string]: unknown;
+}
+export declare function isCommitMeta(v: unknown): v is CommitMeta;
+export declare function validateCommitMeta(v: unknown): ValidationResult;