@natsuneko-laboratory/catalyst-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,548 @@
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+interface Endpoint {
+    readonly path: string;
+    readonly method: HttpMethod;
+    readonly headers?: Record<string, string>;
+    readonly queryParameters?: Record<string, string>;
+    readonly body?: unknown;
+}
+
+interface RequestInterceptor {
+    adapt(request: Request): Promise<Request>;
+    retry(request: Request, error: unknown): Promise<boolean>;
+}
+
+declare class HttpClient {
+    private readonly interceptors;
+    constructor(interceptors?: RequestInterceptor[]);
+    private buildRequest;
+    request<T>(endpoint: Endpoint): Promise<T>;
+    requestVoid(endpoint: Endpoint): Promise<void>;
+    requestRaw(endpoint: Endpoint): Promise<ArrayBuffer>;
+    private executeWithRetry;
+}
+
+interface Identity {
+    id: string;
+}
+
+interface EgeriaUserProfile {
+    iconUrl: string;
+    bannerUrl: string;
+    bio: string;
+    website: string;
+    additionalWebsites: string[];
+}
+interface EgeriaUser {
+    id: string;
+    screenName: string;
+    displayName: string;
+    profile?: EgeriaUserProfile;
+}
+interface EgeriaUserWrapper {
+    user: EgeriaUser;
+}
+interface EgeriaUsers {
+    users: EgeriaUser[];
+}
+interface EgeriaUpdateProfileRequest {
+    screenName?: string;
+    displayName?: string;
+    profile?: EgeriaUserProfile;
+}
+
+interface MediaMetadata {
+    width?: number;
+    height?: number;
+    isSensitive: boolean;
+    isSpoiler: boolean;
+}
+interface Media {
+    id: string;
+    alt: string;
+    url: string;
+    metadata?: MediaMetadata;
+    privacyMetadata?: boolean;
+}
+interface MediaUploadUrls {
+    url: string;
+    signedUrl: string;
+}
+interface CatalystMediaWithMetadata {
+    url: string;
+    alt: string;
+    width: number;
+    height: number;
+    bytes: number;
+}
+interface MediaDeleteRequest {
+    url: string;
+}
+interface MediaDownloadRequest {
+    url: string;
+}
+
+type CatalystStatusPrivacy = "public" | "quiet_public" | "followers" | "private";
+interface CatalystStatus {
+    id: string;
+    body: string;
+    user?: EgeriaUser;
+    medias: Media[];
+    createdAt: string;
+    updatedAt?: string;
+}
+interface CatalystStatusWrapper {
+    status: CatalystStatus;
+}
+interface CatalystStatuses {
+    statuses: CatalystStatus[];
+}
+interface CatalystCreateStatusRequest {
+    description: string;
+    isNsfw: boolean;
+    isSpoiler: boolean;
+    isSubmitToContest: boolean;
+    isHidingLikeAndViewCount: boolean;
+    isPrivateMetadata?: boolean;
+    isAllowComments: boolean;
+    privacy?: CatalystStatusPrivacy;
+    contestId?: string;
+    media: CatalystMediaWithMetadata[];
+}
+interface CatalystEditStatusRequest {
+    description: string;
+}
+
+type CatalystAlbumDisplayMode = "timeline" | "grid" | "gallery";
+interface CatalystAlbum {
+    id: string;
+    name: string;
+    description: string;
+    isPublic: boolean;
+    mode: CatalystAlbumDisplayMode;
+    user: EgeriaUser;
+    statuses: CatalystStatus[];
+}
+interface CatalystSmartAlbum {
+    id: string;
+    name: string;
+    description: string;
+    isAllowNsfw: boolean;
+    isAllowOthers: boolean;
+    since?: string;
+    until?: string;
+    isPublic: boolean;
+    mode: CatalystAlbumDisplayMode;
+    user?: EgeriaUser;
+    type?: string;
+    statuses: CatalystStatus[];
+    hashtags: string[];
+}
+interface CatalystSmartAlbums {
+    albums: CatalystSmartAlbum[];
+}
+interface CatalystCreateAlbumRequest {
+    title: string;
+    description: string;
+    isPublic: boolean;
+    mode: CatalystAlbumDisplayMode;
+}
+interface CatalystEditAlbumRequest {
+    title: string;
+    description: string;
+    isPublic: boolean;
+    mode: CatalystAlbumDisplayMode;
+}
+interface CatalystInsertToAlbumRequest {
+    insert: string;
+}
+interface CatalystRemoveFromAlbumRequest {
+    remove: string;
+}
+interface CatalystCreateSmartAlbumRequest {
+    title: string;
+    description: string;
+    hashtags: string[];
+    since?: string;
+    until?: string;
+    isAllowNsfw?: boolean;
+    isAllowOthers?: boolean;
+    isPublic: boolean;
+    mode?: CatalystAlbumDisplayMode;
+}
+interface CatalystEditSmartAlbumRequest {
+    title: string;
+    description: string;
+    hashtags: string[];
+    since?: string;
+    until?: string;
+    isAllowNsfw?: boolean;
+    isAllowOthers?: boolean;
+    isPublic: boolean;
+    mode?: CatalystAlbumDisplayMode;
+}
+
+interface CatalystReaction {
+    name: string;
+    symbol: string;
+    url: string;
+    count: number;
+    hasSelfReaction?: boolean;
+}
+interface CatalystReactions {
+    reactions: Record<string, CatalystReaction>;
+}
+interface CatalystCustomReaction {
+    name: string;
+    symbol: string;
+    url: string;
+}
+
+interface CatalystRelationships {
+    isMyself: boolean;
+    isFollowing: boolean;
+    isFollowed: boolean;
+}
+interface CatalystRelationshipRequest {
+    userId: string;
+}
+
+declare class CatalystClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    createAlbum(data: CatalystCreateAlbumRequest): Promise<Identity>;
+    getAlbum(id: string, opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystAlbum>;
+    editAlbum(id: string, data: CatalystEditAlbumRequest): Promise<void>;
+    insertToAlbum(id: string, data: CatalystInsertToAlbumRequest): Promise<void>;
+    removeFromAlbum(id: string, data: CatalystRemoveFromAlbumRequest): Promise<void>;
+    deleteAlbum(id: string): Promise<void>;
+    listAlbums(username: string, includeSmartAlbums?: boolean): Promise<CatalystSmartAlbums>;
+    searchAlbums(q: string, includeSmartAlbums?: boolean): Promise<CatalystSmartAlbums>;
+    customReactions(): Promise<CatalystCustomReaction[]>;
+    relationships(id: string): Promise<CatalystRelationships>;
+    follow(data: CatalystRelationshipRequest): Promise<void>;
+    remove(data: CatalystRelationshipRequest): Promise<void>;
+    createSmartAlbum(data: CatalystCreateSmartAlbumRequest): Promise<Identity>;
+    getSmartAlbum(id: string, opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystSmartAlbum>;
+    editSmartAlbum(id: string, data: CatalystEditSmartAlbumRequest): Promise<void>;
+    deleteSmartAlbum(id: string): Promise<void>;
+    searchSmartAlbum(q: string): Promise<CatalystSmartAlbums>;
+    createStatus(data: CatalystCreateStatusRequest): Promise<Identity>;
+    getStatus(id: string): Promise<CatalystStatusWrapper>;
+    editStatus(id: string, data: CatalystEditStatusRequest): Promise<void>;
+    deleteStatus(id: string): Promise<void>;
+    isFavorited(id: string): Promise<boolean>;
+    favorite(id: string): Promise<void>;
+    unfavorite(id: string): Promise<void>;
+    reactions(id: string): Promise<CatalystReactions>;
+    react(id: string, symbol: string): Promise<void>;
+    unreact(id: string, symbol: string): Promise<void>;
+    contestTimeline(slug: string, opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatuses>;
+    favoriteTimeline(opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatuses>;
+    firehoseTimeline(opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatus[]>;
+    galleryTimeline(opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatuses>;
+    homeTimeline(opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatus[]>;
+    searchTimeline(opts?: {
+        q?: string;
+        exact?: boolean;
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatuses>;
+    userTimeline(username: string, opts?: {
+        trimUser?: boolean;
+        excludeSensitive?: boolean;
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatuses>;
+    userGalleryTimeline(username: string, opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<CatalystStatuses>;
+    trend(): Promise<string[]>;
+}
+
+declare class EgeriaClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    me(): Promise<EgeriaUserWrapper | undefined>;
+    update(data: EgeriaUpdateProfileRequest): Promise<void>;
+    search(q: string): Promise<EgeriaUsers>;
+    userById(id: string): Promise<EgeriaUserWrapper | undefined>;
+    userByUsername(username: string): Promise<EgeriaUserWrapper | undefined>;
+}
+
+declare class MediaClient {
+    private readonly http;
+    constructor(http: HttpClient);
+    download(data: MediaDownloadRequest): Promise<ArrayBuffer>;
+    delete(data: MediaDeleteRequest): Promise<void>;
+    upload(): Promise<MediaUploadUrls>;
+}
+
+interface NotificationGroup {
+    id: string;
+    body: string;
+    occurredBy: EgeriaUser;
+    isRead: boolean;
+}
+interface Notification {
+    id: string;
+    title: string;
+    isGrouped: boolean;
+    belongsTo: Record<string, unknown>;
+    entities: NotificationGroup[];
+    hasMore: boolean;
+    read: boolean;
+}
+interface Notifications {
+    notifications: Notification[];
+}
+interface NotificationUnreadCount {
+    unread: number;
+}
+
+declare const ISSUER_CATALYST_SYSTEM_MESSAGE = "natsuneko-laboratory:catalyst";
+declare const ISSUER_CATALYST_USER_MESSAGE = "natsuneko-laboratory:catalyst-message";
+declare const ISSUER_EGERIA_SYSTEM_MESSAGE = "natsuneko-laboratory:egeria";
+declare class SteambirdClient {
+    private readonly http;
+    readonly ISSUER_CATALYST_SYSTEM_MESSAGE = "natsuneko-laboratory:catalyst";
+    readonly ISSUER_CATALYST_USER_MESSAGE = "natsuneko-laboratory:catalyst-message";
+    readonly ISSUER_EGERIA_SYSTEM_MESSAGE = "natsuneko-laboratory:egeria";
+    constructor(http: HttpClient);
+    notifications(issuer: string, opts?: {
+        since?: string;
+        until?: string;
+    }): Promise<Notifications>;
+    read(id: string): Promise<void>;
+    readAll(issuer?: string): Promise<void>;
+    unreads(issuers?: string[]): Promise<NotificationUnreadCount>;
+}
+
+interface Token {
+    accessToken: string;
+    refreshToken: string;
+    tokenType: string;
+}
+
+declare class PKCE {
+    readonly verifier: string;
+    readonly challenge: string;
+    readonly method = "S256";
+    private constructor();
+    static create(): Promise<PKCE>;
+    private static generateVerifier;
+    private static computeChallenge;
+    private static base64url;
+}
+
+declare class OAuthError extends Error {
+    readonly kind: "authorizationRequestFailed" | "invalidAuthorizationResponse" | "invalidTokenResponse";
+    readonly info?: {
+        error: string;
+        description?: string;
+        uri?: string;
+    } | undefined;
+    constructor(message: string, kind: "authorizationRequestFailed" | "invalidAuthorizationResponse" | "invalidTokenResponse", info?: {
+        error: string;
+        description?: string;
+        uri?: string;
+    } | undefined);
+}
+declare class OAuth {
+    private readonly clientId;
+    private readonly clientSecret;
+    constructor(clientId: string, clientSecret: string);
+    getAccessTokenByCode(code: string, redirectUri: string, pkce: PKCE): Promise<Token>;
+    getAccessTokenByRefreshToken(refreshToken: string): Promise<Token>;
+    getAuthorizeURL(redirectUri: string, pkce: PKCE, state: string): URL;
+    getAuthorizationCode(callbackUrl: URL, expectedState: string, expectedRedirectUri: string): string;
+    private verifyAuthorizationResponse;
+    private postToken;
+}
+
+interface CatalystTSOptions {
+    clientId: string;
+    clientSecret: string;
+    accessToken?: string;
+    refreshToken?: string;
+    interceptors?: RequestInterceptor[];
+}
+declare class CatalystTS {
+    readonly clientId: string;
+    readonly clientSecret: string;
+    private _accessToken;
+    private _refreshToken;
+    private readonly http;
+    constructor(opts: CatalystTSOptions);
+    get accessToken(): string | undefined;
+    get refreshToken(): string | undefined;
+    setCredential(accessToken: string, refreshToken: string): void;
+    refresh(): Promise<Token>;
+    get oauth(): OAuth;
+    get catalyst(): CatalystClient;
+    get egeria(): EgeriaClient;
+    get media(): MediaClient;
+    get steambird(): SteambirdClient;
+}
+
+declare class ApiError extends Error {
+    readonly statusCode?: number | undefined;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, statusCode?: number | undefined, cause?: unknown | undefined);
+    static invalid(): ApiError;
+    static httpError(statusCode: number): ApiError;
+    static decodingError(cause: unknown): ApiError;
+    static unauthorized(): ApiError;
+}
+declare class CatalystError extends Error {
+    readonly code?: number | undefined;
+    constructor(message: string, code?: number | undefined);
+}
+
+declare const PUBLIC_API_ENDPOINT = "https://api.natsuneko.com";
+declare const PUBLIC_GRAPHQL_ENDPOINT = "https://graphql.natsuneko.com";
+declare const PUBLIC_AUTHORIZE_ENDPOINT = "https://accounts.natsuneko.com/authorize";
+
+declare const CatalystEndpoint: {
+    readonly createAlbum: (data: CatalystCreateAlbumRequest) => Endpoint;
+    readonly getAlbum: (id: string, opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly editAlbum: (id: string, data: CatalystEditAlbumRequest) => Endpoint;
+    readonly insertToAlbum: (id: string, data: CatalystInsertToAlbumRequest) => Endpoint;
+    readonly removeFromAlbum: (id: string, data: CatalystRemoveFromAlbumRequest) => Endpoint;
+    readonly deleteAlbum: (id: string) => Endpoint;
+    readonly listAlbums: (username: string, includeSmartAlbums?: boolean) => Endpoint;
+    readonly searchAlbum: (q: string, includeSmartAlbums?: boolean) => Endpoint;
+    readonly customReactions: () => Endpoint;
+    readonly relationships: (id: string) => Endpoint;
+    readonly follow: (data: CatalystRelationshipRequest) => Endpoint;
+    readonly remove: (data: CatalystRelationshipRequest) => Endpoint;
+    readonly createSmartAlbum: (data: CatalystCreateSmartAlbumRequest) => Endpoint;
+    readonly getSmartAlbum: (id: string, opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly editSmartAlbum: (id: string, data: CatalystEditSmartAlbumRequest) => Endpoint;
+    readonly deleteSmartAlbum: (id: string) => Endpoint;
+    readonly searchSmartAlbum: (q: string) => Endpoint;
+    readonly createStatus: (data: CatalystCreateStatusRequest) => Endpoint;
+    readonly getStatus: (id: string) => Endpoint;
+    readonly editStatus: (id: string, data: CatalystEditStatusRequest) => Endpoint;
+    readonly deleteStatus: (id: string) => Endpoint;
+    readonly isFavorited: (id: string) => Endpoint;
+    readonly favorite: (id: string) => Endpoint;
+    readonly unfavorite: (id: string) => Endpoint;
+    readonly reactions: (id: string) => Endpoint;
+    readonly react: (id: string, symbol: string) => Endpoint;
+    readonly unreact: (id: string, symbol: string) => Endpoint;
+    readonly contestTimeline: (slug: string, opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly favoriteTimeline: (opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly firehoseTimeline: (opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly galleryTimeline: (opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly homeTimeline: (opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly searchTimeline: (opts?: {
+        q?: string;
+        exact?: boolean;
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly userTimeline: (username: string, opts?: {
+        trimUser?: boolean;
+        excludeSensitive?: boolean;
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly userGalleryTimeline: (username: string, opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly trend: () => Endpoint;
+};
+
+declare const EgeriaEndpoint: {
+    readonly me: () => Endpoint;
+    readonly update: (data: EgeriaUpdateProfileRequest) => Endpoint;
+    readonly search: (q: string) => Endpoint;
+    readonly userById: (id: string) => Endpoint;
+    readonly userByUsername: (username: string) => Endpoint;
+};
+
+declare const MediaEndpoint: {
+    readonly download: (data: MediaDownloadRequest) => Endpoint;
+    readonly delete: (data: MediaDeleteRequest) => Endpoint;
+    readonly upload: () => Endpoint;
+};
+
+declare const SteambirdEndpoint: {
+    readonly notifications: (issuer: string, opts?: {
+        since?: string;
+        until?: string;
+    }) => Endpoint;
+    readonly read: (id: string) => Endpoint;
+    readonly readAll: (issuer?: string) => Endpoint;
+    readonly unreads: (issuers?: string[]) => Endpoint;
+};
+
+declare class AuthInterceptor implements RequestInterceptor {
+    private readonly tokenProvider;
+    private readonly retryCounts;
+    private readonly maxRetryCount;
+    constructor(tokenProvider: () => Promise<string | undefined>);
+    adapt(request: Request): Promise<Request>;
+    retry(request: Request, error: unknown): Promise<boolean>;
+    private makeRequestKey;
+}
+
+declare class UserAgentInterceptor implements RequestInterceptor {
+    private readonly agent;
+    constructor();
+    adapt(request: Request): Promise<Request>;
+    retry(_request: Request, _error: unknown): Promise<boolean>;
+}
+
+declare class LoggingInterceptor implements RequestInterceptor {
+    adapt(request: Request): Promise<Request>;
+    retry(request: Request, error: unknown): Promise<boolean>;
+}
+
+export { ApiError, AuthInterceptor, type CatalystAlbum, type CatalystAlbumDisplayMode, CatalystClient, type CatalystCreateAlbumRequest, type CatalystCreateSmartAlbumRequest, type CatalystCreateStatusRequest, type CatalystCustomReaction, type CatalystEditAlbumRequest, type CatalystEditSmartAlbumRequest, type CatalystEditStatusRequest, CatalystEndpoint, CatalystError, type CatalystInsertToAlbumRequest, type CatalystMediaWithMetadata, type CatalystReaction, type CatalystReactions, type CatalystRelationshipRequest, type CatalystRelationships, type CatalystRemoveFromAlbumRequest, type CatalystSmartAlbum, type CatalystSmartAlbums, type CatalystStatus, type CatalystStatusPrivacy, type CatalystStatusWrapper, type CatalystStatuses, CatalystTS, type CatalystTSOptions, EgeriaClient, EgeriaEndpoint, type EgeriaUpdateProfileRequest, type EgeriaUser, type EgeriaUserProfile, type EgeriaUserWrapper, type EgeriaUsers, type Endpoint, HttpClient, type HttpMethod, ISSUER_CATALYST_SYSTEM_MESSAGE, ISSUER_CATALYST_USER_MESSAGE, ISSUER_EGERIA_SYSTEM_MESSAGE, type Identity, LoggingInterceptor, type Media, MediaClient, type MediaDeleteRequest, type MediaDownloadRequest, MediaEndpoint, type MediaMetadata, type MediaUploadUrls, type Notification, type NotificationGroup, type NotificationUnreadCount, type Notifications, OAuth, OAuthError, PKCE, PUBLIC_API_ENDPOINT, PUBLIC_AUTHORIZE_ENDPOINT, PUBLIC_GRAPHQL_ENDPOINT, type RequestInterceptor, SteambirdClient, SteambirdEndpoint, type Token, UserAgentInterceptor };