@clioplaylists/clio 0.1.0 → 0.1.2

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

@@ -0,0 +1,51 @@
+/**
+ * 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;
+    /** Compare and swap with the previous record by CID. */
+    swapRecord?: string;
+    /** Compare and swap with the previous commit by CID. */
+    swapCommit?: string;
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    commit?: ComAtprotoRepoDefs.CommitMeta;
+    [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/describeRepo.d.ts

@@ -0,0 +1,43 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+    /** The handle or DID of the repo. */
+    repo: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    handle: string;
+    did: string;
+    /** The complete DID document for this account. */
+    didDoc: {};
+    /** List of all the collections (NSIDs) for which this repo contains at least one record. */
+    collections: string[];
+    /** Indicates if handle is currently valid (resolves bi-directionally) */
+    handleIsCorrect: boolean;
+    [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/repo/getRecord.d.ts

@@ -0,0 +1,45 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+    /** The handle or DID of the repo. */
+    repo: string;
+    /** The NSID of the record collection. */
+    collection: string;
+    /** The Record Key. */
+    rkey: string;
+    /** The CID of the version of the record. If not specified, then return the most recent version. */
+    cid?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    uri: string;
+    cid?: string;
+    value: {};
+    [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?: 'RecordNotFound';
+}
+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/importRepo.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth } from '@atproto/xrpc-server';
+import express from 'express';
+import stream from 'stream';
+export interface QueryParams {
+}
+export type InputSchema = string | Uint8Array | Blob;
+export interface HandlerInput {
+    encoding: 'application/vnd.ipld.car';
+    body: stream.Readable;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export type HandlerOutput = HandlerError | void;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+    resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

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

@@ -0,0 +1,45 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+    limit: number;
+    cursor?: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    blobs: RecordBlob[];
+    [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;
+export interface RecordBlob {
+    cid: string;
+    recordUri: string;
+    [k: string]: unknown;
+}
+export declare function isRecordBlob(v: unknown): v is RecordBlob;
+export declare function validateRecordBlob(v: unknown): ValidationResult;

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

@@ -0,0 +1,53 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+    /** The handle or DID of the repo. */
+    repo: string;
+    /** The NSID of the record type. */
+    collection: string;
+    /** The number of records to return. */
+    limit: number;
+    cursor?: string;
+    /** Flag to reverse the order of the returned records. */
+    reverse?: boolean;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    cursor?: string;
+    records: Record[];
+    [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;
+export interface Record {
+    uri: string;
+    cid: string;
+    value: {};
+    [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/repo/putRecord.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 to write. */
+    record: {};
+    /** Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation */
+    swapRecord?: string | null;
+    /** 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/strongRef.d.ts

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

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

@@ -0,0 +1,39 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef } from '@atproto/lexicon';
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+import stream from 'stream';
+export interface QueryParams {
+}
+export type InputSchema = string | Uint8Array | Blob;
+export interface OutputSchema {
+    blob: BlobRef;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: '*/*';
+    body: stream.Readable;
+}
+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/server/activateAccount.d.ts

@@ -0,0 +1,23 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export type InputSchema = undefined;
+export type HandlerInput = undefined;
+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/server/checkAccountStatus.d.ts

@@ -0,0 +1,42 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    activated: boolean;
+    validDid: boolean;
+    repoCommit: string;
+    repoRev: string;
+    repoBlocks: number;
+    indexedRecords: number;
+    privateStateValues: number;
+    expectedBlobs: number;
+    importedBlobs: number;
+    [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/server/confirmEmail.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    email: string;
+    token: string;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+    error?: 'AccountNotFound' | 'ExpiredToken' | 'InvalidToken' | 'InvalidEmail';
+}
+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/server/createAccount.d.ts

@@ -0,0 +1,61 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    email?: string;
+    /** Requested handle for the account. */
+    handle: string;
+    /** Pre-existing atproto DID, being imported to a new account. */
+    did?: string;
+    inviteCode?: string;
+    verificationCode?: string;
+    verificationPhone?: string;
+    /** Initial account password. May need to meet instance-specific password strength requirements. */
+    password?: string;
+    /** DID PLC rotation key (aka, recovery key) to be included in PLC creation operation. */
+    recoveryKey?: string;
+    /** A signed DID PLC operation to be submitted as part of importing an existing account to this instance. NOTE: this optional field may be updated when full account migration is implemented. */
+    plcOp?: {};
+    [k: string]: unknown;
+}
+/** Account login session returned on successful account creation. */
+export interface OutputSchema {
+    accessJwt: string;
+    refreshJwt: string;
+    handle: string;
+    /** The DID of the new account. */
+    did: string;
+    /** Complete DID document. */
+    didDoc?: {};
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerSuccess {
+    encoding: 'application/json';
+    body: OutputSchema;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+    error?: 'InvalidHandle' | 'InvalidPassword' | 'InvalidInviteCode' | 'HandleNotAvailable' | 'UnsupportedDomain' | 'UnresolvableDid' | 'IncompatibleDidDoc';
+}
+export type HandlerOutput = HandlerError | HandlerSuccess | 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/server/createAppPassword.d.ts

@@ -0,0 +1,51 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    /** A short name for the App Password, to help distinguish them. */
+    name: string;
+    /** If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients. */
+    privileged?: boolean;
+    [k: string]: unknown;
+}
+export type OutputSchema = AppPassword;
+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?: 'AccountTakedown';
+}
+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;
+export interface AppPassword {
+    name: string;
+    password: string;
+    createdAt: string;
+    privileged?: boolean;
+    [k: string]: unknown;
+}
+export declare function isAppPassword(v: unknown): v is AppPassword;
+export declare function validateAppPassword(v: unknown): ValidationResult;

package/dist/lexicons/types/com/atproto/server/createInviteCode.d.ts

@@ -0,0 +1,41 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    useCount: number;
+    forAccount?: string;
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    code: 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/server/createInviteCodes.d.ts

@@ -0,0 +1,50 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult } from '@atproto/lexicon';
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import express from 'express';
+export interface QueryParams {
+}
+export interface InputSchema {
+    codeCount: number;
+    useCount: number;
+    forAccounts?: string[];
+    [k: string]: unknown;
+}
+export interface OutputSchema {
+    codes: AccountCodes[];
+    [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;
+export interface AccountCodes {
+    account: string;
+    codes: string[];
+    [k: string]: unknown;
+}
+export declare function isAccountCodes(v: unknown): v is AccountCodes;
+export declare function validateAccountCodes(v: unknown): ValidationResult;