@notidotbot/noti-api-client 1.4.0

package/dist/classes/teams.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APITeams = void 0;
+// Data.
+class APITeams {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getAllUserTeams({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/teams'),
+        });
+    }
+    async createTeam({ auth, teamName }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/data/teams'),
+            body: { teamName },
+        });
+    }
+    async joinOrLeaveTeam({ auth, teamOrCode, action }) {
+        const query = action === 'join' ? { code: teamOrCode } : { teamId: teamOrCode };
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp(`/data/teams/${action}`, query),
+        });
+    }
+    async createTeamInvite({ auth, teamId, maxUses, bitfieldToSet, expiresAt }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp(`/data/teams/${teamId}/invite`),
+            body: { maxUses, bitfieldToSet, expiresAt },
+        });
+    }
+    async kickTeamMember({ auth, teamId, userId }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp(`/data/teams/${teamId}/kick`),
+            body: { userId },
+        });
+    }
+    async updateMemberPermissions({ auth, teamId, userId, bitfieldToSet }) {
+        return await this.web.request({
+            method: 'PUT', auth,
+            endpoint: this.web.qp(`/data/teams/${teamId}/update`),
+            body: { userId, bitfieldToSet },
+        });
+    }
+    async updateTeamName({ auth, teamId, teamName }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp(`/data/teams/${teamId}`),
+            body: { teamName },
+        });
+    }
+    async deleteTeam({ auth, teamId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/teams/${teamId}`),
+        });
+    }
+}
+exports.APITeams = APITeams;

package/dist/classes/telemetry.d.ts

@@ -0,0 +1,32 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+import { Guild, User } from '../other/prisma';
+export declare class APITelemetry {
+    private web;
+    constructor(web: WebDataManager);
+    getTelemetry<T extends string>({ auth, guildId }: TelemetryFunctionsInput<T>['getTelemetry']): Promise<import("../types").WebResponse<Telemetry<T>>>;
+    toggleTelemetry({ auth, type, ...rest }: TelemetryFunctionsInput['toggleTelemetry']): Promise<import("../types").WebResponse<string>>;
+}
+export type TelemetryFunctionsInput<T extends string = never> = {
+    'getTelemetry': {
+        auth: string;
+        guildId?: T;
+    };
+    'toggleTelemetry': {
+        auth: string;
+    } & ({
+        guildId?: T;
+        type: 'dismissAds';
+    } | {
+        type: 'overlayGenerated';
+    });
+};
+export type TelemetryReturnTypes = {
+    'getTelemetryRaw': Awaited<ReturnType<APITelemetry['getTelemetry']>>;
+    'getTelemetrySuccess': CancelOutWebResponses<Awaited<ReturnType<APITelemetry['getTelemetry']>>>;
+    'toggleTelemetryRaw': Awaited<ReturnType<APITelemetry['toggleTelemetry']>>;
+    'toggleTelemetrySuccess': CancelOutWebResponses<Awaited<ReturnType<APITelemetry['toggleTelemetry']>>>;
+};
+export type Telemetry<GuildId extends string = never> = GuildId extends string ? GuildTelemetry : UserTelemetry;
+export type UserTelemetry = NonNullable<User['gettingStarted']>;
+export type GuildTelemetry = NonNullable<Guild['gettingStarted']>;

package/dist/classes/telemetry.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APITelemetry = void 0;
+// Data.
+class APITelemetry {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getTelemetry({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/telemetry', {
+                guild: guildId,
+            }),
+        });
+    }
+    async toggleTelemetry({ auth, type, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/telemetry/${type}`, {
+                guild: 'guildId' in rest ? rest.guildId : undefined,
+            }),
+        });
+    }
+}
+exports.APITelemetry = APITelemetry;

package/dist/classes/user.d.ts

@@ -0,0 +1,40 @@
+import { CancelOutWebResponses, DeepPartial } from '../types';
+import { WebDataManager } from '../core/manager';
+import { UserZod } from '../other/prisma';
+import { CurrentUser } from './@me';
+export declare class APIUser {
+    private web;
+    constructor(web: WebDataManager);
+    getUser({ auth, userId }: UserFunctionsInput['getUser']): Promise<import("../types").WebResponse<UserResponse>>;
+    updateUser({ auth, userId, user }: UserFunctionsInput['updateUser']): Promise<import("../types").WebResponse<string>>;
+    deleteUser({ auth, userId }: UserFunctionsInput['getUser']): Promise<import("../types").WebResponse<string>>;
+}
+export type UserFunctionsInput = {
+    'getUser': {
+        auth: string;
+        userId: string;
+    };
+    'updateUser': {
+        auth: string;
+        userId: string;
+        user: DeepPartial<UserZod>;
+    };
+    'deleteUser': {
+        auth: string;
+        userId: string;
+    };
+};
+export type UserReturnTypes = {
+    'getUserRaw': Awaited<ReturnType<APIUser['getUser']>>;
+    'getUserSuccess': CancelOutWebResponses<Awaited<ReturnType<APIUser['getUser']>>>;
+    'updateUserRaw': Awaited<ReturnType<APIUser['updateUser']>>;
+    'updateUserSuccess': CancelOutWebResponses<Awaited<ReturnType<APIUser['updateUser']>>>;
+    'deleteUserRaw': Awaited<ReturnType<APIUser['deleteUser']>>;
+    'deleteUserSuccess': CancelOutWebResponses<Awaited<ReturnType<APIUser['deleteUser']>>>;
+};
+export type UserResponse = Omit<CurrentUser, 'discord' | 'database'> & UserWithPremium;
+export type UserWithPremium = CurrentUser['database'] & {
+    premium: {
+        enabled: boolean;
+    };
+};

package/dist/classes/user.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIUser = void 0;
+// Data.
+class APIUser {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getUser({ auth, userId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/user/' + userId),
+        });
+    }
+    async updateUser({ auth, userId, user }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body: user,
+            endpoint: this.web.qp('/data/user/' + userId),
+        });
+    }
+    async deleteUser({ auth, userId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/user/' + userId),
+        });
+    }
+}
+exports.APIUser = APIUser;

package/dist/classes/vods.d.ts

@@ -0,0 +1,55 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+export declare class APIVods {
+    private web;
+    constructor(web: WebDataManager);
+    getTotalFiles({ auth }: VodsFunctionsInput['getTotalFiles']): Promise<import("../types").WebResponse<VodResponse>>;
+    getGuildFileVodData({ guildId, fileKey }: VodsFunctionsInput['getGuildFileVodData']): Promise<import("../types").WebResponse<VodGuildFileData>>;
+    getVodFileData({ auth, fileKey }: VodsFunctionsInput['getVodFileData']): Promise<import("../types").WebResponse<VodFileData>>;
+    deleteVod({ auth, fileKey }: VodsFunctionsInput['deleteVod']): Promise<import("../types").WebResponse<true>>;
+}
+export type VodsFunctionsInput = {
+    'getTotalFiles': {
+        auth: string;
+    };
+    'getGuildFileVodData': {
+        guildId: string;
+        fileKey: string;
+    };
+    'getVodFileData': {
+        auth: string;
+        fileKey: string;
+    };
+    'deleteVod': {
+        auth: string;
+        fileKey: string;
+    };
+};
+export type R2ReturnTypes = {
+    'getTotalFilesRaw': Awaited<ReturnType<APIVods['getTotalFiles']>>;
+    'getTotalFilesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIVods['getTotalFiles']>>>;
+    'getGuildFileVodDataRaw': Awaited<ReturnType<APIVods['getGuildFileVodData']>>;
+    'getGuildFileVodDataSuccess': CancelOutWebResponses<Awaited<ReturnType<APIVods['getGuildFileVodData']>>>;
+    'getVodFileDataRaw': Awaited<ReturnType<APIVods['getVodFileData']>>;
+    'getVodFileDataSuccess': CancelOutWebResponses<Awaited<ReturnType<APIVods['getVodFileData']>>>;
+    'deleteVodRaw': Awaited<ReturnType<APIVods['deleteVod']>>;
+    'deleteVodSuccess': CancelOutWebResponses<Awaited<ReturnType<APIVods['deleteVod']>>>;
+};
+export type VodResponse = {
+    totalVodsInR2: number;
+    registeredFiles: number;
+};
+export type VodGuildFileData = {
+    guildId: string;
+    allowedUntil: Date;
+    tempUrl: string;
+};
+export type VodFileData = {
+    key: string;
+    contentType?: string;
+    contentLength?: number;
+    lastModified?: number;
+    expiresAt?: string;
+    allowedGuilds: string[];
+    tempUrl: string;
+};

package/dist/classes/vods.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIVods = void 0;
+// Data.
+class APIVods {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getTotalFiles({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/vods'),
+        });
+    }
+    async getGuildFileVodData({ guildId, fileKey }) {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/data/vods/' + guildId + '/' + fileKey, {
+                noRedirect: true,
+            }),
+        });
+    }
+    async getVodFileData({ auth, fileKey }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/vods/' + fileKey),
+        });
+    }
+    async deleteVod({ auth, fileKey }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/data/vods/' + fileKey),
+        });
+    }
+}
+exports.APIVods = APIVods;

package/dist/core/manager.d.ts

@@ -0,0 +1,57 @@
+import { APIPlatformAction } from '../classes/guildPlatformAction';
+import { APIGuildStarboard } from '../classes/guildStarboard';
+import { APIGuildPlatform } from '../classes/guildPlatform';
+import { APIGuildGiveaway } from '../classes/guildGiveaway';
+import { AxiosResponse } from 'axios';
+import { RequestMethod, WebResponse } from '../types';
+import { APITelemetry } from '../classes/telemetry';
+import { APISessions } from '../classes/sessions';
+import { APIPlatform } from '../classes/platform';
+import { APIPremium } from '../classes/premium';
+import { APILinked } from '../classes/linked';
+import { APIClient } from '../classes/client';
+import { APITeams } from '../classes/teams';
+import { APIOther } from '../classes/other';
+import { APIGuild } from '../classes/guild';
+import { APIFiles } from '../classes/files';
+import { APIAdmin } from '../classes/admin';
+import { APIVods } from '../classes/vods';
+import { APIUser } from '../classes/user';
+import { APIMe } from '../classes/@me';
+export declare class WebDataManager {
+    url: string;
+    options?: {
+        log?: boolean;
+    } | undefined;
+    readonly me: APIMe;
+    readonly user: APIUser;
+    readonly vods: APIVods;
+    readonly files: APIFiles;
+    readonly admin: APIAdmin;
+    readonly other: APIOther;
+    readonly guild: APIGuild;
+    readonly teams: APITeams;
+    readonly client: APIClient;
+    readonly linked: APILinked;
+    readonly premium: APIPremium;
+    readonly platform: APIPlatform;
+    readonly sessions: APISessions;
+    readonly telemetry: APITelemetry;
+    readonly guildPlatform: APIGuildPlatform;
+    readonly guildGiveaway: APIGuildGiveaway;
+    readonly guildStarboard: APIGuildStarboard;
+    readonly guildPlatformAction: APIPlatformAction;
+    constructor(url: string, options?: {
+        log?: boolean;
+    } | undefined);
+    request<O, T = unknown, C extends boolean = false>(data: {
+        method: RequestMethod;
+        endpoint: string;
+        body?: T;
+        auth?: string;
+        raw?: C;
+        headers?: Record<string, string> | null;
+        doNotStringify?: boolean;
+    }): Promise<C extends false ? WebResponse<O> : AxiosResponse<O>>;
+    qp<T extends Record<string, unknown>>(url: string, params?: T): string;
+}

package/dist/core/manager.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDataManager = void 0;
+const guildPlatformAction_1 = require("../classes/guildPlatformAction");
+const guildStarboard_1 = require("../classes/guildStarboard");
+const guildPlatform_1 = require("../classes/guildPlatform");
+const guildGiveaway_1 = require("../classes/guildGiveaway");
+const axios_1 = __importDefault(require("axios"));
+const telemetry_1 = require("../classes/telemetry");
+const sessions_1 = require("../classes/sessions");
+const platform_1 = require("../classes/platform");
+const premium_1 = require("../classes/premium");
+const linked_1 = require("../classes/linked");
+const client_1 = require("../classes/client");
+const teams_1 = require("../classes/teams");
+const other_1 = require("../classes/other");
+const guild_1 = require("../classes/guild");
+const files_1 = require("../classes/files");
+const admin_1 = require("../classes/admin");
+const vods_1 = require("../classes/vods");
+const user_1 = require("../classes/user");
+const utils_1 = require("./utils");
+const _me_1 = require("../classes/@me");
+class WebDataManager {
+    url;
+    options;
+    me = new _me_1.APIMe(this);
+    user = new user_1.APIUser(this);
+    vods = new vods_1.APIVods(this);
+    files = new files_1.APIFiles(this);
+    admin = new admin_1.APIAdmin(this);
+    other = new other_1.APIOther(this);
+    guild = new guild_1.APIGuild(this);
+    teams = new teams_1.APITeams(this);
+    client = new client_1.APIClient(this);
+    linked = new linked_1.APILinked(this);
+    premium = new premium_1.APIPremium(this);
+    platform = new platform_1.APIPlatform(this);
+    sessions = new sessions_1.APISessions(this);
+    telemetry = new telemetry_1.APITelemetry(this);
+    guildPlatform = new guildPlatform_1.APIGuildPlatform(this);
+    guildGiveaway = new guildGiveaway_1.APIGuildGiveaway(this);
+    guildStarboard = new guildStarboard_1.APIGuildStarboard(this);
+    guildPlatformAction = new guildPlatformAction_1.APIPlatformAction(this);
+    constructor(url, options) {
+        this.url = url;
+        this.options = options;
+    }
+    async request(data) {
+        axios_1.default.interceptors.response.use(utils_1.transformDates);
+        return await (0, axios_1.default)(this.url + data.endpoint, {
+            method: data.method,
+            data: data.body ? data.doNotStringify ? data.body : JSON.stringify(data.body) : undefined,
+            headers: {
+                ...(data.headers === null ? {} : { 'Content-Type': 'application/json' }),
+                ...(data.auth ? { 'Authorization': data.auth } : {}),
+                ...(data.headers || {}),
+            },
+        })
+            .then((res) => data.raw ? res : res.data)
+            .catch((err) => data.raw ? err.response : err.response?.data);
+    }
+    qp(url, params) {
+        if (!params)
+            return url;
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined)
+                continue;
+            query.append(key, String(value));
+        }
+        return url + '?' + query.toString();
+    }
+}
+exports.WebDataManager = WebDataManager;

package/dist/core/utils.d.ts

@@ -0,0 +1,4 @@
+import { AxiosResponse } from 'axios';
+export declare function isDateStringRegex(value: unknown): value is string;
+export declare function recursiveDateConversion<T>(data: T): T;
+export declare function transformDates<T>(response: AxiosResponse<T>): AxiosResponse<T>;

package/dist/core/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDateStringRegex = isDateStringRegex;
+exports.recursiveDateConversion = recursiveDateConversion;
+exports.transformDates = transformDates;
+function isDateStringRegex(value) {
+    const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+    return typeof value === 'string' && isoPattern.test(value);
+}
+function recursiveDateConversion(data) {
+    if (data instanceof Date)
+        return new Date(data);
+    if (Array.isArray(data))
+        return data.map(recursiveDateConversion);
+    if (typeof data === 'object' && data !== null) {
+        for (const key in data) {
+            data[key] = recursiveDateConversion(data[key]);
+        }
+    }
+    return isDateStringRegex(data) ? new Date(data) : data;
+}
+function transformDates(response) {
+    if (response.data)
+        response.data = recursiveDateConversion(response.data);
+    return response;
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from './core/manager';
+export * from './types';
+export * from './classes/@me';
+export * from './classes/user';
+export * from './classes/admin';
+export * from './classes/files';
+export * from './classes/other';
+export * from './classes/guild';
+export * from './classes/teams';
+export * from './classes/client';
+export * from './classes/linked';
+export * from './classes/premium';
+export * from './classes/platform';
+export * from './classes/sessions';
+export * from './classes/telemetry';
+export * from './classes/guildPlatform';
+export * from './classes/guildGiveaway';
+export * from './classes/guildStarboard';
+export * from './classes/guildPlatformAction';
+export { GuildMessageTypeEnum, StreamerMessageTypeEnum, PlatformEnum, $Enums } from './other/enums';
+export type { Prisma, TSPrisma } from '@prisma/client';
+export type { ClientChangelog, Guild, User, Team, Member, KickStreamer, TwitchStreamer, YoutubeStreamer, TiktokStreamer, RumbleStreamer, GuildGiveaway } from '@prisma/client';

package/dist/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Enums = exports.PlatformEnum = exports.StreamerMessageTypeEnum = exports.GuildMessageTypeEnum = void 0;
+__exportStar(require("./core/manager"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./classes/@me"), exports);
+__exportStar(require("./classes/user"), exports);
+__exportStar(require("./classes/admin"), exports);
+__exportStar(require("./classes/files"), exports);
+__exportStar(require("./classes/other"), exports);
+__exportStar(require("./classes/guild"), exports);
+__exportStar(require("./classes/teams"), exports);
+__exportStar(require("./classes/client"), exports);
+__exportStar(require("./classes/linked"), exports);
+__exportStar(require("./classes/premium"), exports);
+__exportStar(require("./classes/platform"), exports);
+__exportStar(require("./classes/sessions"), exports);
+__exportStar(require("./classes/telemetry"), exports);
+__exportStar(require("./classes/guildPlatform"), exports);
+__exportStar(require("./classes/guildGiveaway"), exports);
+__exportStar(require("./classes/guildStarboard"), exports);
+__exportStar(require("./classes/guildPlatformAction"), exports);
+// Re-export Prisma generated enums (browser-safe)
+var enums_1 = require("./other/enums");
+Object.defineProperty(exports, "GuildMessageTypeEnum", { enumerable: true, get: function () { return enums_1.GuildMessageTypeEnum; } });
+Object.defineProperty(exports, "StreamerMessageTypeEnum", { enumerable: true, get: function () { return enums_1.StreamerMessageTypeEnum; } });
+Object.defineProperty(exports, "PlatformEnum", { enumerable: true, get: function () { return enums_1.PlatformEnum; } });
+Object.defineProperty(exports, "$Enums", { enumerable: true, get: function () { return enums_1.$Enums; } });

package/dist/modules/stripe.d.ts

@@ -0,0 +1,12 @@
+import { DeepNonNullable, DeepRequired } from '../types';
+import { RemoveDBIds } from 'ts-prisma';
+import { Guild } from '../other/prisma';
+export declare const addonKeys: (keyof ListOfAdditionalAddons)[];
+export type AdditionalNames = keyof ListOfAdditionalAddons;
+export type AddDefault<T> = T extends string ? `default${T}` : never;
+export type RemoveAdditional<T> = T extends `additional${infer R}` ? R : T;
+export type AddonNames = RemoveAdditional<keyof ListOfAdditionalAddons> & string;
+export type DefaultAddons = AddDefault<AddonNames>;
+export declare const addonNames: AddonNames[];
+export declare const defaultAddons: DefaultAddons[];
+export type ListOfAdditionalAddons = RemoveDBIds<DeepNonNullable<Omit<NonNullable<DeepRequired<Guild>['premium']>, 'tier' | 'enabled'>>, 'dbId' | 'guildId'>;

package/dist/modules/stripe.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAddons = exports.addonNames = exports.addonKeys = void 0;
+exports.addonKeys = [
+    'additionalStickyMessages',
+    'additionalAutoLiveRoles',
+    'additionalLinkedRoles',
+    'additionalStatusRoles',
+    'additionalStarboards',
+    'additionalOverrides',
+    'additionalKickConnections',
+    'additionalRumbleConnections',
+    'additionalTwitchConnections',
+    'additionalYoutubeConnections',
+    'additionalTiktokConnections',
+];
+exports.addonNames = exports.addonKeys.map((k) => k.replace('additional', ''));
+exports.defaultAddons = exports.addonNames.map((k) => `default${k}`);