@clioplaylists/clio 0.1.7 → 0.1.9

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

@@ -1,11 +1,11 @@
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import { ValidationResult } from '@atproto/lexicon';
+import { type ValidationResult } from '@atproto/lexicon';
 export interface Main {
+    $type?: 'com.atproto.repo.strongRef';
     uri: string;
     cid: string;
-    [k: string]: unknown;
 }
-export declare function isMain(v: unknown): v is Main;
-export declare function validateMain(v: unknown): ValidationResult;
+export declare function isMain<V>(v: V): v is import("../../../../util").$TypedObject<V, "com.atproto.repo.strongRef", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;

package/dist/lexicons/types/com/atproto/repo/strongRef.js

@@ -1,11 +1,15 @@
-import { lexicons } from '../../../../lexicons';
-import { hasProp, isObj } from '../../../../util';
-export function isMain(v) {
-    return (isObj(v) &&
-        hasProp(v, '$type') &&
-        (v.$type === 'com.atproto.repo.strongRef#main' ||
-            v.$type === 'com.atproto.repo.strongRef'));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMain = isMain;
+exports.validateMain = validateMain;
+const lexicons_1 = require("../../../../lexicons");
+const util_1 = require("../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.atproto.repo.strongRef';
+const hashMain = 'main';
+function isMain(v) {
+    return is$typed(v, id, hashMain);
 }
-export function validateMain(v) {
-    return lexicons.validate('com.atproto.repo.strongRef#main', v);
+function validateMain(v) {
+    return validate(v, id, hashMain);
 }

package/dist/lexicons/types/com/clioplaylists/alpha/actor/profile.d.ts

@@ -1,19 +1,21 @@
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import { BlobRef, ValidationResult } from '@atproto/lexicon';
-import * as ComAtprotoRepoStrongRef from '../../../atproto/repo/strongRef';
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+import type * as ComAtprotoRepoStrongRef from '../../../atproto/repo/strongRef.js';
 export interface Record {
-    displayName?: string;
-    /** Free-form profile description text. */
-    description?: string;
+    $type: 'com.clioplaylists.alpha.actor.profile';
+    displayName: string;
+    /** Free-form profile bio text. */
+    bio?: string;
     /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
     avatar?: BlobRef;
     /** Larger horizontal image to display behind profile view. */
     banner?: BlobRef;
     pinnedPlaylistIdea?: ComAtprotoRepoStrongRef.Main;
-    createdAt?: string;
+    /** Client-declared timestamp when this record was originally created. */
+    createdAt: string;
     [k: string]: unknown;
 }
-export declare function isRecord(v: unknown): v is Record;
-export declare function validateRecord(v: unknown): ValidationResult;
+export declare function isRecord<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.actor.profile", "main">;
+export declare function validateRecord<V>(v: V): ValidationResult<Record & V>;

package/dist/lexicons/types/com/clioplaylists/alpha/actor/profile.js

@@ -1,11 +1,15 @@
-import { lexicons } from '../../../../../lexicons';
-import { hasProp, isObj } from '../../../../../util';
-export function isRecord(v) {
-    return (isObj(v) &&
-        hasProp(v, '$type') &&
-        (v.$type === 'com.clioplaylists.alpha.actor.profile#main' ||
-            v.$type === 'com.clioplaylists.alpha.actor.profile'));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecord = isRecord;
+exports.validateRecord = validateRecord;
+const lexicons_1 = require("../../../../../lexicons");
+const util_1 = require("../../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.clioplaylists.alpha.actor.profile';
+const hashRecord = 'main';
+function isRecord(v) {
+    return is$typed(v, id, hashRecord);
 }
-export function validateRecord(v) {
-    return lexicons.validate('com.clioplaylists.alpha.actor.profile#main', v);
+function validateRecord(v) {
+    return validate(v, id, hashRecord, true);
 }

package/dist/lexicons/types/com/clioplaylists/alpha/feed/defs.d.ts

@@ -1,8 +1,9 @@
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import { BlobRef, ValidationResult } from '@atproto/lexicon';
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
 export interface Song {
+    $type?: 'com.clioplaylists.alpha.feed.defs#song';
     /** The title of the track. */
     trackName: string;
     /** Array of artist names in order of original appearance. */
@@ -12,21 +13,29 @@ export interface Song {
     /** Array of Musicbrainz artist IDs. */
     artistMbIds: string[];
     /** Image associated with the song's album. */
-    albumArtwork?: BlobRef;
-    /** Client-declared timestamp when this record was originally created. */
-    createdAt?: string;
-    [k: string]: unknown;
+    albumArtworkRef?: BlobRef;
 }
-export declare function isSong(v: unknown): v is Song;
-export declare function validateSong(v: unknown): ValidationResult;
+export declare function isSong<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.feed.defs", "song">;
+export declare function validateSong<V>(v: V): ValidationResult<Song & V>;
 export interface SongView {
+    $type?: 'com.clioplaylists.alpha.feed.defs#songView';
     trackName: string;
     artistNames: string[];
     trackMbId: string;
     artistMbIds: string[];
     albumArtwork?: BlobRef;
-    indexedAt?: string;
-    [k: string]: unknown;
 }
-export declare function isSongView(v: unknown): v is SongView;
-export declare function validateSongView(v: unknown): ValidationResult;
+export declare function isSongView<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.feed.defs", "songView">;
+export declare function validateSongView<V>(v: V): ValidationResult<SongView & V>;
+export interface RecommendedPlaylistView {
+    $type?: 'com.clioplaylists.alpha.feed.defs#recommendedPlaylistView';
+    uri: string;
+    cid: string;
+    songs: SongView[];
+    playlistIdeaUri: string;
+    /** Handle of the recommender and owner of this playlist. */
+    ownerHandle: string;
+    playlistArtwork?: BlobRef;
+}
+export declare function isRecommendedPlaylistView<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.feed.defs", "recommendedPlaylistView">;
+export declare function validateRecommendedPlaylistView<V>(v: V): ValidationResult<RecommendedPlaylistView & V>;

package/dist/lexicons/types/com/clioplaylists/alpha/feed/defs.js

@@ -1,18 +1,33 @@
-import { lexicons } from '../../../../../lexicons';
-import { hasProp, isObj } from '../../../../../util';
-export function isSong(v) {
-    return (isObj(v) &&
-        hasProp(v, '$type') &&
-        v.$type === 'com.clioplaylists.alpha.feed.defs#song');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSong = isSong;
+exports.validateSong = validateSong;
+exports.isSongView = isSongView;
+exports.validateSongView = validateSongView;
+exports.isRecommendedPlaylistView = isRecommendedPlaylistView;
+exports.validateRecommendedPlaylistView = validateRecommendedPlaylistView;
+const lexicons_1 = require("../../../../../lexicons");
+const util_1 = require("../../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.clioplaylists.alpha.feed.defs';
+const hashSong = 'song';
+function isSong(v) {
+    return is$typed(v, id, hashSong);
 }
-export function validateSong(v) {
-    return lexicons.validate('com.clioplaylists.alpha.feed.defs#song', v);
+function validateSong(v) {
+    return validate(v, id, hashSong);
 }
-export function isSongView(v) {
-    return (isObj(v) &&
-        hasProp(v, '$type') &&
-        v.$type === 'com.clioplaylists.alpha.feed.defs#songView');
+const hashSongView = 'songView';
+function isSongView(v) {
+    return is$typed(v, id, hashSongView);
 }
-export function validateSongView(v) {
-    return lexicons.validate('com.clioplaylists.alpha.feed.defs#songView', v);
+function validateSongView(v) {
+    return validate(v, id, hashSongView);
+}
+const hashRecommendedPlaylistView = 'recommendedPlaylistView';
+function isRecommendedPlaylistView(v) {
+    return is$typed(v, id, hashRecommendedPlaylistView);
+}
+function validateRecommendedPlaylistView(v) {
+    return validate(v, id, hashRecommendedPlaylistView);
 }

package/dist/lexicons/types/com/clioplaylists/alpha/feed/getRecommendedPlaylistsByUser.d.ts

@@ -0,0 +1,36 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express';
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server';
+import type * as ComClioplaylistsAlphaFeedDefs from './defs.js';
+export interface QueryParams {
+    /** The handle or did of the user to return recommended playlists for. */
+    userAtIdentifier: string;
+}
+export type InputSchema = undefined;
+export interface OutputSchema {
+    recommendedPlaylists: ComClioplaylistsAlphaFeedDefs.RecommendedPlaylistView[];
+}
+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/clioplaylists/alpha/feed/getRecommendedPlaylistsByUser.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexicons_1 = require("../../../../../lexicons");
+const util_1 = require("../../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.clioplaylists.alpha.feed.getRecommendedPlaylistsByUser';

package/dist/lexicons/types/com/clioplaylists/alpha/feed/playlistIdea.d.ts

@@ -1,9 +1,10 @@
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import { ValidationResult } from '@atproto/lexicon';
-import * as ComClioplaylistsAlphaFeedDefs from './defs';
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+import type * as ComClioplaylistsAlphaFeedDefs from './defs.js';
 export interface Record {
+    $type: 'com.clioplaylists.alpha.feed.playlistIdea';
     /** A concise title that gives other users an idea of the vibe of the playlist. */
     title: string;
     /** A description of the playlist that explains more about what the user is looking for from the playlist. */
@@ -11,22 +12,18 @@ export interface Record {
     creatorDid: string;
     ownerDid: string;
     masterPlaylist?: MasterPlaylist;
-    recommendedPlaylist?: RecommendedPlaylist;
     /** Client-declared timestamp when this record was originally created. */
     createdAt: string;
     [k: string]: unknown;
 }
-export declare function isRecord(v: unknown): v is Record;
-export declare function validateRecord(v: unknown): ValidationResult;
+export declare function isRecord<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.feed.playlistIdea", "main">;
+export declare function validateRecord<V>(v: V): ValidationResult<Record & V>;
+/** The playlist of songs that the creator officially says are representative of the idea. */
 export interface MasterPlaylist {
+    $type?: 'com.clioplaylists.alpha.feed.playlistIdea#masterPlaylist';
     songs: ComClioplaylistsAlphaFeedDefs.Song[];
-    [k: string]: unknown;
-}
-export declare function isMasterPlaylist(v: unknown): v is MasterPlaylist;
-export declare function validateMasterPlaylist(v: unknown): ValidationResult;
-export interface RecommendedPlaylist {
-    songs: ComClioplaylistsAlphaFeedDefs.Song[];
-    [k: string]: unknown;
+    /** Image associated with the playlist. */
+    playlistArtwork?: BlobRef;
 }
-export declare function isRecommendedPlaylist(v: unknown): v is RecommendedPlaylist;
-export declare function validateRecommendedPlaylist(v: unknown): ValidationResult;
+export declare function isMasterPlaylist<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.feed.playlistIdea", "masterPlaylist">;
+export declare function validateMasterPlaylist<V>(v: V): ValidationResult<MasterPlaylist & V>;

package/dist/lexicons/types/com/clioplaylists/alpha/feed/playlistIdea.js

@@ -1,27 +1,24 @@
-import { lexicons } from '../../../../../lexicons';
-import { hasProp, isObj } from '../../../../../util';
-export function isRecord(v) {
-    return (isObj(v) &&
-        hasProp(v, '$type') &&
-        (v.$type === 'com.clioplaylists.alpha.feed.playlistIdea#main' ||
-            v.$type === 'com.clioplaylists.alpha.feed.playlistIdea'));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecord = isRecord;
+exports.validateRecord = validateRecord;
+exports.isMasterPlaylist = isMasterPlaylist;
+exports.validateMasterPlaylist = validateMasterPlaylist;
+const lexicons_1 = require("../../../../../lexicons");
+const util_1 = require("../../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.clioplaylists.alpha.feed.playlistIdea';
+const hashRecord = 'main';
+function isRecord(v) {
+    return is$typed(v, id, hashRecord);
 }
-export function validateRecord(v) {
-    return lexicons.validate('com.clioplaylists.alpha.feed.playlistIdea#main', v);
+function validateRecord(v) {
+    return validate(v, id, hashRecord, true);
 }
-export function isMasterPlaylist(v) {
-    return (isObj(v) &&
-        hasProp(v, '$type') &&
-        v.$type === 'com.clioplaylists.alpha.feed.playlistIdea#masterPlaylist');
+const hashMasterPlaylist = 'masterPlaylist';
+function isMasterPlaylist(v) {
+    return is$typed(v, id, hashMasterPlaylist);
 }
-export function validateMasterPlaylist(v) {
-    return lexicons.validate('com.clioplaylists.alpha.feed.playlistIdea#masterPlaylist', v);
-}
-export function isRecommendedPlaylist(v) {
-    return (isObj(v) &&
-        hasProp(v, '$type') &&
-        v.$type === 'com.clioplaylists.alpha.feed.playlistIdea#recommendedPlaylist');
-}
-export function validateRecommendedPlaylist(v) {
-    return lexicons.validate('com.clioplaylists.alpha.feed.playlistIdea#recommendedPlaylist', v);
+function validateMasterPlaylist(v) {
+    return validate(v, id, hashMasterPlaylist);
 }

package/dist/lexicons/types/com/clioplaylists/alpha/feed/recommendedPlaylist.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon';
+import type * as ComClioplaylistsAlphaFeedDefs from './defs.js';
+export interface Main {
+    $type?: 'com.clioplaylists.alpha.feed.recommendedPlaylist';
+    /** Songs that the user recommends for the playlist idea. */
+    songs: ComClioplaylistsAlphaFeedDefs.Song[];
+    /** The at-uri of the playlist idea that these recommendations are for. */
+    playlistIdeaAtUri: string;
+    /** DID of the recommender and owner of this playlist. */
+    ownerDid: string;
+    /** Image associated with the playlist. */
+    playlistArtwork?: BlobRef;
+}
+export declare function isMain<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.feed.recommendedPlaylist", "main">;
+export declare function validateMain<V>(v: V): ValidationResult<Main & V>;

package/dist/lexicons/types/com/clioplaylists/alpha/feed/recommendedPlaylist.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMain = isMain;
+exports.validateMain = validateMain;
+const lexicons_1 = require("../../../../../lexicons");
+const util_1 = require("../../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.clioplaylists.alpha.feed.recommendedPlaylist';
+const hashMain = 'main';
+function isMain(v) {
+    return is$typed(v, id, hashMain);
+}
+function validateMain(v) {
+    return validate(v, id, hashMain);
+}

package/dist/lexicons/types/com/clioplaylists/alpha/feed/songRecommendation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+import type * as ComAtprotoRepoStrongRef from '../../../atproto/repo/strongRef.js';
+import type * as ComClioplaylistsAlphaFeedDefs from './defs.js';
+export interface Record {
+    $type: 'com.clioplaylists.alpha.feed.songRecommendation';
+    playlistIdea: ComAtprotoRepoStrongRef.Main;
+    song: ComClioplaylistsAlphaFeedDefs.Song;
+    /** Optional note from the recommender explaining why this song fits. */
+    note?: string;
+    /** Client-declared timestamp when this record was originally created. */
+    createdAt: string;
+    [k: string]: unknown;
+}
+export declare function isRecord<V>(v: V): v is import("../../../../../util").$TypedObject<V, "com.clioplaylists.alpha.feed.songRecommendation", "main">;
+export declare function validateRecord<V>(v: V): ValidationResult<Record & V>;

package/dist/lexicons/types/com/clioplaylists/alpha/feed/songRecommendation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecord = isRecord;
+exports.validateRecord = validateRecord;
+const lexicons_1 = require("../../../../../lexicons");
+const util_1 = require("../../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.clioplaylists.alpha.feed.songRecommendation';
+const hashRecord = 'main';
+function isRecord(v) {
+    return is$typed(v, id, hashRecord);
+}
+function validateRecord(v) {
+    return validate(v, id, hashRecord, true);
+}

package/dist/lexicons/util.d.ts

@@ -1,5 +1,36 @@
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-export declare function isObj(v: unknown): v is Record<string, unknown>;
-export declare function hasProp<K extends PropertyKey>(data: object, prop: K): data is Record<K, unknown>;
+import { type ValidationResult } from '@atproto/lexicon';
+export type OmitKey<T, K extends keyof T> = {
+    [K2 in keyof T as K2 extends K ? never : K2]: T[K2];
+};
+export type $Typed<V, T extends string = string> = V & {
+    $type: T;
+};
+export type Un$Typed<V extends {
+    $type?: string;
+}> = OmitKey<V, '$type'>;
+export type $Type<Id extends string, Hash extends string> = Hash extends 'main' ? Id : `${Id}#${Hash}`;
+export type $TypedObject<V, Id extends string, Hash extends string> = V extends {
+    $type: $Type<Id, Hash>;
+} ? V : V extends {
+    $type?: string;
+} ? V extends {
+    $type?: infer T extends $Type<Id, Hash>;
+} ? V & {
+    $type: T;
+} : never : V & {
+    $type: $Type<Id, Hash>;
+};
+export declare function is$typed<V, Id extends string, Hash extends string>(v: V, id: Id, hash: Hash): v is $TypedObject<V, Id, Hash>;
+export declare function maybe$typed<V, Id extends string, Hash extends string>(v: V, id: Id, hash: Hash): v is V & object & {
+    $type?: $Type<Id, Hash>;
+};
+export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>;
+export type ValidatorParam<V extends Validator> = V extends Validator<infer R> ? R : never;
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+export declare function asPredicate<V extends Validator>(validate: V): <T>(v: T) => v is T & ValidatorParam<V>;

package/dist/lexicons/util.js

@@ -1,9 +1,37 @@
+"use strict";
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-export function isObj(v) {
-    return typeof v === 'object' && v !== null;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.is$typed = is$typed;
+exports.maybe$typed = maybe$typed;
+exports.asPredicate = asPredicate;
+function isObject(v) {
+    return v != null && typeof v === 'object';
 }
-export function hasProp(data, prop) {
-    return prop in data;
+function is$type($type, id, hash) {
+    return hash === 'main'
+        ? $type === id
+        : // $type === `${id}#${hash}`
+            typeof $type === 'string' &&
+                $type.length === id.length + 1 + hash.length &&
+                $type.charCodeAt(id.length) === 35 /* '#' */ &&
+                $type.startsWith(id) &&
+                $type.endsWith(hash);
+}
+function is$typed(v, id, hash) {
+    return isObject(v) && '$type' in v && is$type(v.$type, id, hash);
+}
+function maybe$typed(v, id, hash) {
+    return (isObject(v) &&
+        ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true));
+}
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+function asPredicate(validate) {
+    return function (v) {
+        return validate(v).success;
+    };
 }

package/dist/logger.js

@@ -1,19 +1,25 @@
-import { obfuscateHeaders, subsystemLogger } from '@atproto/common';
-import { stdSerializers } from 'pino';
-import pinoHttp from 'pino-http';
-export const dbLogger = subsystemLogger('clio:db');
-export const subLogger = subsystemLogger('clio:sub');
-export const httpLogger = subsystemLogger('clio');
-export const loggerMiddleware = pinoHttp({
-    logger: httpLogger,
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerMiddleware = exports.httpLogger = exports.subLogger = exports.dbLogger = void 0;
+const common_1 = require("@atproto/common");
+const pino_1 = require("pino");
+const pino_http_1 = __importDefault(require("pino-http"));
+exports.dbLogger = (0, common_1.subsystemLogger)('clio:db');
+exports.subLogger = (0, common_1.subsystemLogger)('clio:sub');
+exports.httpLogger = (0, common_1.subsystemLogger)('clio');
+exports.loggerMiddleware = (0, pino_http_1.default)({
+    logger: exports.httpLogger,
     serializers: {
         err: (err) => ({
             code: err?.['code'],
             message: err?.['message'],
         }),
         req: (req) => {
-            const serialized = stdSerializers.req(req);
-            const headers = obfuscateHeaders(serialized.headers);
+            const serialized = pino_1.stdSerializers.req(req);
+            const headers = (0, common_1.obfuscateHeaders)(serialized.headers);
             return { ...serialized, headers };
         },
     },

package/dist/oauth/client.d.ts

@@ -0,0 +1,14 @@
+import { OAuthClient } from '@atproto/oauth-client';
+import { NodeOAuthClient } from '@atproto/oauth-client-node';
+import type AppContext from '../context';
+import { Database } from '../dataplane/server/db';
+type RedirectUri = NonNullable<Parameters<OAuthClient['authorize']>[1] extends {
+    redirect_uri?: infer R;
+} ? R : never>;
+export declare const getOauthRedirectUri: (ctx: AppContext) => RedirectUri;
+export declare const getOauthDb: (ctx: AppContext) => Database;
+type NodeOauthOptions = ConstructorParameters<typeof NodeOAuthClient>[0];
+type ClientMetadata = NodeOauthOptions['clientMetadata'];
+export declare const getOauthClientMetadata: (ctx: AppContext) => ClientMetadata;
+export declare const getOauthClient: (ctx: AppContext) => OAuthClient;
+export {};