@notidotbot/noti-api-client 1.4.0

package/cname.js

@@ -0,0 +1,3 @@
+const fs = require('node:fs');
+
+fs.writeFileSync('./docs/CNAME', 'api-docs.noti.bot');

package/dist/classes/@me.d.ts

@@ -0,0 +1,122 @@
+import { PlatformsToLinkType, User } from '../other/prisma';
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+export declare class APIMe {
+    private web;
+    constructor(web: WebDataManager);
+    getCurrentUser({ auth }: MeFunctionsInput['getCurrentUser']): Promise<import("../types").WebResponse<CurrentUser>>;
+    clearCurrentUserNotifications({ auth }: MeFunctionsInput['clearCurrentUserNotifications']): Promise<import("../types").WebResponse<true>>;
+    getCurrentUserGuilds({ auth }: MeFunctionsInput['getCurrentUserGuilds']): Promise<import("../types").WebResponse<CurrentUserGuilds>>;
+    getGuildDiscordData<T extends GuildDataType>({ auth, guildId, types, force }: MeFunctionsInput['getGuildDiscordData']): Promise<import("../types").WebResponse<DiscordGuildData<T>>>;
+    getConnectPlatformUrl({ platform }: MeFunctionsInput['getConnectPlatformUrl']): Promise<import("../types").WebResponse<string>>;
+    connectPlatform({ auth, platform, code, state }: MeFunctionsInput['connectPlatform']): Promise<import("../types").WebResponse<string>>;
+    unlinkPlatform({ auth, platform }: MeFunctionsInput['unlinkPlatform']): Promise<import("../types").WebResponse<string>>;
+}
+export type MeFunctionsInput<T extends GuildDataType = never> = {
+    'getCurrentUser': {
+        auth: string;
+    };
+    'clearCurrentUserNotifications': {
+        auth: string;
+    };
+    'getCurrentUserGuilds': {
+        auth: string;
+    };
+    'getGuildDiscordData': {
+        auth: string;
+        guildId: string;
+        types: T[];
+        force?: boolean;
+    };
+    'getConnectPlatformUrl': {
+        auth: string;
+        platform: 'twitch' | 'kick';
+    };
+    'connectPlatform': {
+        auth: string;
+        platform: PlatformsToLinkType;
+        code: string;
+        state?: string;
+    };
+    'unlinkPlatform': {
+        auth: string;
+        platform: PlatformsToLinkType;
+    };
+};
+export type MeGetReturnTypes = {
+    'getCurrentUserRaw': Awaited<ReturnType<APIMe['getCurrentUser']>>;
+    'getCurrentUserSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['getCurrentUser']>>>;
+    'clearCurrentUserNotificationsRaw': Awaited<ReturnType<APIMe['clearCurrentUserNotifications']>>;
+    'clearCurrentUserNotificationsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['clearCurrentUserNotifications']>>>;
+    'getCurrentUserGuildsRaw': Awaited<ReturnType<APIMe['getCurrentUserGuilds']>>;
+    'getCurrentUserGuildsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['getCurrentUserGuilds']>>>;
+    'getGuildDiscordDataRaw': Awaited<ReturnType<APIMe['getGuildDiscordData']>>;
+    'getGuildDiscordDataSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['getGuildDiscordData']>>>;
+    'getConnectPlatformUrlRaw': Awaited<ReturnType<APIMe['getConnectPlatformUrl']>>;
+    'getConnectPlatformUrlSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['getConnectPlatformUrl']>>>;
+    'connectPlatformRaw': Awaited<ReturnType<APIMe['connectPlatform']>>;
+    'connectPlatformSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['connectPlatform']>>>;
+    'unlinkPlatformRaw': Awaited<ReturnType<APIMe['unlinkPlatform']>>;
+    'unlinkPlatformSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['unlinkPlatform']>>>;
+};
+export type DCUserData = {
+    id: string;
+    email: string | null;
+    avatar: string | null;
+    banner: string | null;
+    isBotDev: boolean;
+    username: string;
+    globalName: string | null;
+    accentColor: string;
+    discriminator: string;
+    useNewUsername: boolean;
+};
+export type ModToSomene = {
+    userId: string;
+    username: string;
+    kickAccount: string | null;
+    twitchAccount: string | null;
+    rumbleAccount: string | null;
+}[];
+export type CurrentUser = {
+    isDev: boolean;
+    isStaff: boolean;
+    discord: DCUserData;
+    database: User & {
+        premium: {
+            enabled: boolean;
+        } | null;
+    };
+};
+export type CurrentUserGuilds = {
+    id: string;
+    name: string;
+    icon: string | null;
+    banner: string | null;
+    isBotIn: boolean;
+}[];
+export type GuildDataType = 'channels' | 'roles' | 'emojis';
+export type DiscordGuildData<T extends GuildDataType = GuildDataType> = {
+    [K in T]: K extends 'channels' ? {
+        id: string;
+        name: string;
+        validPermissions: boolean;
+        missingPermissions: string[];
+    }[] : K extends 'roles' ? {
+        id: string;
+        name: string;
+        validPermissions: boolean;
+        reasons: string[];
+    }[] : K extends 'emojis' ? {
+        list: {
+            id: string;
+            name: string | null;
+            animated: boolean;
+        }[];
+        maxEach: number;
+        current: {
+            normal: number;
+            animated: number;
+        };
+    } : never;
+};

package/dist/classes/@me.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIMe = void 0;
+// Data.
+class APIMe {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getCurrentUser({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/@me'),
+        });
+    }
+    async clearCurrentUserNotifications({ auth }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/@me/notifications'),
+        });
+    }
+    async getCurrentUserGuilds({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/@me/guilds'),
+        });
+    }
+    async getGuildDiscordData({ auth, guildId, types, force }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/@me/guilds/' + guildId, {
+                types,
+                force,
+            }),
+        });
+    }
+    async getConnectPlatformUrl({ platform }) {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/@me/connect/' + platform),
+        });
+    }
+    async connectPlatform({ auth, platform, code, state }) {
+        return await this.web.request({
+            method: 'POST', auth, body: { code },
+            endpoint: this.web.qp('/@me/connect/' + platform, {
+                state,
+            }),
+        });
+    }
+    async unlinkPlatform({ auth, platform }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/@me/connect/' + platform),
+        });
+    }
+}
+exports.APIMe = APIMe;

package/dist/classes/admin.d.ts

@@ -0,0 +1,71 @@
+import { FirstCapital, AllPlatforms } from '../other/prisma';
+import { CancelOutWebResponses } from '../types';
+import { WebDataManager } from '../core/manager';
+export declare class APIAdmin {
+    private web;
+    constructor(web: WebDataManager);
+    getEmailList({ auth }: AdminFunctionsInput['getEmailList']): Promise<import("../types").WebResponse<EmailList>>;
+    getAnalytics<T extends string = string>({ auth, lookback }: AdminFunctionsInput['getAnalytics']): Promise<import("../types").WebResponse<Analytics<T, string>>>;
+}
+export type AdminFunctionsInput = {
+    'getEmailList': {
+        auth: string;
+    };
+    'getAnalytics': {
+        auth: string;
+        lookback?: number;
+    };
+};
+export type AdminGetReturnTypes = {
+    'getEmailListRaw': Awaited<ReturnType<APIAdmin['getEmailList']>>;
+    'getEmailListSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdmin['getEmailList']>>>;
+    'getAnalyticsRaw': Awaited<ReturnType<APIAdmin['getAnalytics']>>;
+    'getAnalyticsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIAdmin['getAnalytics']>>>;
+};
+export type EmailList = {
+    userId: string;
+    email: string;
+}[];
+export type Analytics<B extends string = string, C extends string = string> = {
+    db: DBAnalytics;
+    commands: AnalyticsData<C>;
+    buttons: AnalyticsData<B>;
+};
+export type DBAnalytics = {
+    totalUsers: number;
+    totalGuilds: number;
+    totalTeams: number;
+    totalR2Objects: number;
+    totalServersUsingX: {
+        birthday: number;
+        welcomeLeaves: number;
+        statusRoles: number;
+        autoLiveRoles: number;
+        notificationOverrides: number;
+    };
+    totalUsersLinkedWith: {
+        kick: number;
+        twitch: number;
+        rumble: number;
+    };
+    totalGiveaways: number;
+    totalNotifications: number;
+    totalStatChannels: number;
+    totalStatusRoles: number;
+    totalClips: number;
+    totalVods: number;
+} & Record<`total${FirstCapital<AllPlatforms>}Streamers`, number>;
+export type AnalyticsData<T extends string = string> = {
+    global: {
+        daily: Record<string, number>;
+        weekly: Record<string, number>;
+        monthly: Record<string, number>;
+    };
+    usages: {
+        [key in T]: {
+            daily: Record<string, number>;
+            weekly: Record<string, number>;
+            monthly: Record<string, number>;
+        };
+    };
+};

package/dist/classes/admin.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIAdmin = void 0;
+// Data.
+class APIAdmin {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getEmailList({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/emails'),
+        });
+    }
+    async getAnalytics({ auth, lookback }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/analytics', {
+                lookback,
+            }),
+        });
+    }
+}
+exports.APIAdmin = APIAdmin;

package/dist/classes/client.d.ts

@@ -0,0 +1,156 @@
+import { Client, ClientZod } from '../other/prisma';
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+export declare class APIClient {
+    private web;
+    constructor(web: WebDataManager);
+    getFaqAnswers({ auth, question }: ClientFunctionsInput['getFaqAnswers']): Promise<import("../types").WebResponse<FaqReturnType[]>>;
+    askFaq({ auth, body }: ClientFunctionsInput['askFaq']): Promise<import("../types").WebResponse<string>>;
+    getFaqData({ auth, questionIdentifier }: ClientFunctionsInput['getFaqData']): Promise<import("../types").WebResponse<FaqReturnType>>;
+    createFaq({ auth, body }: ClientFunctionsInput['createFaq']): Promise<import("../types").WebResponse<string>>;
+    updateFaq({ auth, questionIdentifier, body }: ClientFunctionsInput['updateFaq']): Promise<import("../types").WebResponse<string>>;
+    deleteFaq({ auth, questionIdentifier }: ClientFunctionsInput['deleteFaq']): Promise<import("../types").WebResponse<string>>;
+    getNews(): Promise<import("../types").WebResponse<{
+        dbId: string;
+        date: Date;
+        title: string;
+        thumbnail: string | null;
+        clientId: string;
+        identifier: string;
+        isPublic: boolean;
+        changes: string[];
+    }[]>>;
+    getNewsAdmin({ auth }: ClientFunctionsInput['getNewsAdmin']): Promise<import("../types").WebResponse<{
+        dbId: string;
+        date: Date;
+        title: string;
+        thumbnail: string | null;
+        clientId: string;
+        identifier: string;
+        isPublic: boolean;
+        changes: string[];
+    }[]>>;
+    createNews({ auth, body }: ClientFunctionsInput['createNews']): Promise<import("../types").WebResponse<string>>;
+    deleteNews({ auth, identifier }: ClientFunctionsInput['deleteNews']): Promise<import("../types").WebResponse<string>>;
+    updateNews({ auth, identifier, body }: ClientFunctionsInput['updateNews']): Promise<import("../types").WebResponse<string>>;
+    getBlogs(): Promise<import("../types").WebResponse<BlogWithout<"reactions">[]>>;
+    getBlogsAdmin({ auth }: ClientFunctionsInput['getBlogsAdmin']): Promise<import("../types").WebResponse<{
+        dbId: string;
+        title: string;
+        content: string;
+        thumbnail: string | null;
+        authorIcon: string;
+        clientId: string;
+        identifier: string;
+        isPinned: boolean;
+        views: number | null;
+        reactions: string[];
+        reactionsCount: number | null;
+        tags: string[];
+        authorName: string;
+        createdAt: Date;
+        lastEdited: Date;
+        isPublic: boolean;
+    }[]>>;
+    getBlog({ identifier }: ClientFunctionsInput['getBlog']): Promise<import("../types").WebResponse<BlogWithout<"reactions">>>;
+    createBlog({ auth, body }: ClientFunctionsInput['createBlog']): Promise<import("../types").WebResponse<string>>;
+    updateBlog({ auth, identifier, body }: ClientFunctionsInput['updateBlog']): Promise<import("../types").WebResponse<string>>;
+    deleteBlog({ auth, identifier }: ClientFunctionsInput['deleteBlog']): Promise<import("../types").WebResponse<string>>;
+}
+export type ClientFunctionsInput = {
+    'getFaqAnswers': {
+        auth: string;
+        question?: string;
+    };
+    'askFaq': {
+        auth: string;
+        body: AskFaqBody;
+    };
+    'getFaqData': {
+        auth: string;
+        questionIdentifier: string;
+    };
+    'createFaq': {
+        auth: string;
+        body: Omit<ClientZod['faq'][number], 'identifier'>;
+    };
+    'updateFaq': {
+        auth: string;
+        questionIdentifier: string;
+        body: Partial<Omit<ClientZod['faq'][number], 'identifier'>>;
+    };
+    'deleteFaq': {
+        auth: string;
+        questionIdentifier: string;
+    };
+    'createNews': {
+        auth: string;
+        body: ClientZod['changelogs'][number];
+    };
+    'updateNews': {
+        auth: string;
+        identifier: string;
+        body: Partial<Omit<ClientZod['changelogs'][number], 'identifier'>>;
+    };
+    'getNewsAdmin': {
+        auth: string;
+    };
+    'deleteNews': {
+        auth: string;
+        identifier: string;
+    };
+    'getBlog': {
+        identifier: string;
+    };
+    'getBlogsAdmin': {
+        auth: string;
+    };
+    'createBlog': {
+        auth: string;
+        body: Omit<ClientZod['blogs'][number], BlogToOmitCreate>;
+    };
+    'updateBlog': {
+        auth: string;
+        identifier: string;
+        body: Partial<Omit<ClientZod['blogs'][number], BlogToOmitUpdate>>;
+    };
+    'deleteBlog': {
+        auth: string;
+        identifier: string;
+    };
+};
+export type ClientReturnTypes = {
+    'getFaqAnswersRaw': Awaited<ReturnType<APIClient['getFaqAnswers']>>;
+    'getFaqAnswersSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getFaqAnswers']>>>;
+    'askFaqRaw': Awaited<ReturnType<APIClient['askFaq']>>;
+    'askFaqSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['askFaq']>>>;
+    'getFaqDataRaw': Awaited<ReturnType<APIClient['getFaqData']>>;
+    'getFaqDataSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getFaqData']>>>;
+    'createFaqRaw': Awaited<ReturnType<APIClient['createFaq']>>;
+    'createFaqSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['createFaq']>>>;
+    'updateFaqRaw': Awaited<ReturnType<APIClient['updateFaq']>>;
+    'updateFaqSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['updateFaq']>>>;
+    'deleteFaqRaw': Awaited<ReturnType<APIClient['deleteFaq']>>;
+    'deleteFaqSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['deleteFaq']>>>;
+    'getNewsRaw': Awaited<ReturnType<APIClient['getNews']>>;
+    'getNewsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['getNews']>>>;
+    'createNewsRaw': Awaited<ReturnType<APIClient['createNews']>>;
+    'createNewsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['createNews']>>>;
+    'deleteNewsRaw': Awaited<ReturnType<APIClient['deleteNews']>>;
+    'deleteNewsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIClient['deleteNews']>>>;
+};
+export type FaqReturnType = {
+    dbId: string;
+    identifier: string;
+    question: string | null;
+    answer: string | null;
+    clientId: string;
+};
+export type AskFaqBody = {
+    question: string;
+    username: string;
+    avatarUrl: string;
+};
+export type BlogWithout<T extends keyof Client['blogs'][number] = never> = Omit<Client['blogs'][number], T>;
+export type BlogToOmitCreate = 'views' | 'reactions' | 'reactionsCount' | 'createdAt' | 'lastEdited';
+export type BlogToOmitUpdate = 'identifier' | BlogToOmitCreate;

package/dist/classes/client.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIClient = void 0;
+// Data.
+class APIClient {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getFaqAnswers({ auth, question }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/faq', {
+                question,
+            }),
+        });
+    }
+    async askFaq({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/data/faq/ask'),
+        });
+    }
+    async getFaqData({ auth, questionIdentifier }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/faq/' + questionIdentifier),
+        });
+    }
+    async createFaq({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/data/faq'),
+        });
+    }
+    async updateFaq({ auth, questionIdentifier, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/data/faq/' + questionIdentifier),
+        });
+    }
+    async deleteFaq({ auth, questionIdentifier }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/faq/' + questionIdentifier),
+        });
+    }
+    async getNews() {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/data/news'),
+        });
+    }
+    async getNewsAdmin({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/news/raw'),
+        });
+    }
+    async createNews({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/data/news'),
+        });
+    }
+    async deleteNews({ auth, identifier }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/news/' + identifier),
+        });
+    }
+    async updateNews({ auth, identifier, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/data/news/' + identifier),
+        });
+    }
+    async getBlogs() {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/data/blogs'),
+        });
+    }
+    async getBlogsAdmin({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/blogs/raw'),
+        });
+    }
+    async getBlog({ identifier }) {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/data/blogs/' + identifier),
+        });
+    }
+    async createBlog({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/data/blogs'),
+        });
+    }
+    async updateBlog({ auth, identifier, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/data/blogs/' + identifier),
+        });
+    }
+    async deleteBlog({ auth, identifier }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/blogs/' + identifier),
+        });
+    }
+}
+exports.APIClient = APIClient;

package/dist/classes/emotes.d.ts

@@ -0,0 +1,31 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+export declare class APIEmotes {
+    private web;
+    constructor(web: WebDataManager);
+    getEmotesFor({ auth, platform, username }: EmotesFunctionsInput['getEmotesFor']): Promise<import("../types").WebResponse<EmojiType[]>>;
+    createDownloadZip({ auth, emotes }: EmotesFunctionsInput['createDownloadZip']): Promise<import("../types").WebResponse<DownloadZipType>>;
+}
+export type EmotesFunctionsInput = {
+    'getEmotesFor': {
+        auth: string;
+        platform: string;
+        username: string;
+    };
+    'createDownloadZip': {
+        auth: string;
+        emotes: Omit<EmojiType, 'id'>[];
+    };
+};
+export type EmotesReturnTypes = {
+    'getEmotesForRaw': Awaited<ReturnType<APIEmotes['getEmotesFor']>>;
+    'getEmotesForSuccess': CancelOutWebResponses<Awaited<ReturnType<APIEmotes['getEmotesFor']>>>;
+};
+export type EmojiType = {
+    id: string;
+    name: string;
+    url: string;
+};
+export type DownloadZipType = {
+    id: string;
+};

package/dist/classes/emotes.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIEmotes = void 0;
+// Data.
+class APIEmotes {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getEmotesFor({ auth, platform, username }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/emotes/${platform}/${username}`),
+        });
+    }
+    async createDownloadZip({ auth, emotes }) {
+        return await this.web.request({
+            method: 'POST', auth, body: emotes,
+            endpoint: this.web.qp('/data/emotes'),
+        });
+    }
+}
+exports.APIEmotes = APIEmotes;

package/dist/classes/files.d.ts

@@ -0,0 +1,36 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+export declare class APIFiles {
+    private web;
+    constructor(web: WebDataManager);
+    getFiles({ auth }: FilesFunctionsInput['getFiles']): Promise<import("../types").WebResponse<AllFiles>>;
+    uploadFile({ auth, key, file }: FilesFunctionsInput['uploadFile']): Promise<import("../types").WebResponse<string>>;
+    deleteFile({ auth, key }: FilesFunctionsInput['deleteFile']): Promise<import("../types").WebResponse<string>>;
+}
+export type FilesFunctionsInput = {
+    'getFiles': {
+        auth: string;
+    };
+    'uploadFile': {
+        auth: string;
+        key: string;
+        file: Blob;
+    };
+    'deleteFile': {
+        auth: string;
+        key: string;
+    };
+};
+export type FilesReturnTypes = {
+    'getFilesRaw': Awaited<ReturnType<APIFiles['getFiles']>>;
+    'getFilesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFiles['getFiles']>>>;
+    'uploadFileRaw': Awaited<ReturnType<APIFiles['uploadFile']>>;
+    'uploadFileSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFiles['uploadFile']>>>;
+    'deleteFileRaw': Awaited<ReturnType<APIFiles['deleteFile']>>;
+    'deleteFileSuccess': CancelOutWebResponses<Awaited<ReturnType<APIFiles['deleteFile']>>>;
+};
+export type AllFiles = {
+    key?: string;
+    size?: number;
+    lastModified?: string;
+}[];