@notidotbot/noti-api-client 1.4.14 → 1.4.16

package/dist/classes/other.d.ts

@@ -6,28 +6,50 @@ export declare class APIOther {
     status<T extends boolean>({ withTopServers }?: {
         withTopServers?: T;
     }): Promise<import("../types").WebResponse<StatusType<T>>>;
+    guildStatus({ auth, guildId }: OtherFunctionsInput['guildStatus']): Promise<import("../types").WebResponse<GuildStatusType>>;
     recentActivity(): Promise<import("../types").WebResponse<RecentActivityType>>;
+    scheduler({ auth, body }: OtherFunctionsInput['scheduler']): Promise<import("../types").WebResponse<string>>;
     checkRateLimit({ auth }: OtherFunctionsInput['checkRateLimit']): Promise<import("../types").WebResponse<string>>;
     getAllLanguages(): Promise<import("../types").WebResponse<LanguageList>>;
-    oAuth2({ guildId }: OtherFunctionsInput['oAuth2']): Promise<import("../types").WebResponse<OAuth2Type>>;
+    oAuth2({ state, guildId }?: OtherFunctionsInput['oAuth2']): Promise<import("../types").WebResponse<OAuth2Type>>;
+    eval({ auth, body }: OtherFunctionsInput['eval']): Promise<import("../types").WebResponse<unknown>>;
     isDown(): Promise<boolean>;
 }
 export type OtherFunctionsInput = {
+    'guildStatus': {
+        auth: string;
+        guildId: string;
+    };
+    'scheduler': {
+        auth: string;
+        body: SchedulerBody;
+    };
     'checkRateLimit': {
         auth: string;
     };
     'getAllLanguages': never;
     'oAuth2': {
+        state?: OAuth2State;
         guildId?: string;
     };
+    'eval': {
+        auth: string;
+        body: EvalBody;
+    };
 };
 export type OtherReturnTypes = {
+    'guildStatusRaw': Awaited<ReturnType<APIOther['guildStatus']>>;
+    'guildStatusSuccess': CancelOutWebResponses<Awaited<ReturnType<APIOther['guildStatus']>>>;
+    'schedulerRaw': Awaited<ReturnType<APIOther['scheduler']>>;
+    'schedulerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIOther['scheduler']>>>;
     'checkRateLimitRaw': Awaited<ReturnType<APIOther['checkRateLimit']>>;
     'checkRateLimitSuccess': CancelOutWebResponses<Awaited<ReturnType<APIOther['checkRateLimit']>>>;
     'getAllLanguagesRaw': Awaited<ReturnType<APIOther['getAllLanguages']>>;
     'getAllLanguagesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIOther['getAllLanguages']>>>;
     'oAuth2Raw': Awaited<ReturnType<APIOther['oAuth2']>>;
     'oAuth2Success': CancelOutWebResponses<Awaited<ReturnType<APIOther['oAuth2']>>>;
+    'evalRaw': Awaited<ReturnType<APIOther['eval']>>;
+    'evalSuccess': CancelOutWebResponses<Awaited<ReturnType<APIOther['eval']>>>;
 };
 export type LanguageList = {
     name: string;
@@ -38,14 +60,34 @@ export type RecentActivityType = {
     message: string;
     createdAt: number;
 }[];
+export type OAuth2State = 'l' | 'd' | 'c';
 export type OAuth2Type = {
     login: string;
     invite: string;
 };
+export type SchedulerBody = Record<string, unknown>;
+export type EvalBody = {
+    code: string;
+    context: 'client' | 'manager';
+};
+export type EvalResponse = unknown;
+export type GuildStatusType = {
+    id: string;
+    name: string;
+    icon: string | null;
+    isVerified: boolean;
+    isPartnered: boolean;
+    shardData: {
+        shardId: number;
+        shardPing: number;
+        status: string;
+    };
+};
 export type StatusType<T extends boolean = false> = {
     devMode: boolean;
     shardsPerClusters: number;
     totalStreamers: number;
+    totalGiveaways: number;
     totalNotifications: number;
     totalStatChannels: number;
     totalStatusRoles: number;

package/dist/classes/other.js

@@ -16,12 +16,24 @@ class APIOther {
             }),
         });
     }
+    async guildStatus({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/status/' + guildId),
+        });
+    }
     async recentActivity() {
         return await this.web.request({
             method: 'GET',
             endpoint: this.web.qp('/recent'),
         });
     }
+    async scheduler({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/scheduler'),
+        });
+    }
     async checkRateLimit({ auth }) {
         return await this.web.request({
             method: 'GET', auth,
@@ -34,14 +46,21 @@ class APIOther {
             endpoint: this.web.qp('/data/languages'),
         });
     }
-    async oAuth2({ guildId }) {
+    async oAuth2({ state, guildId } = {}) {
         return await this.web.request({
             method: 'GET',
             endpoint: this.web.qp('/oauth2', {
+                state,
                 guildId,
             }),
         });
     }
+    async eval({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/eval'),
+        });
+    }
     async isDown() {
         const response = await this.web.request({
             method: 'GET',

package/dist/classes/platform.d.ts

@@ -4,8 +4,8 @@ import { AllPlatforms } from '../other/prisma';
 export declare class APIPlatform {
     private web;
     constructor(web: WebDataManager);
-    getActivePlatforms({ auth }: PlatformFunctionsInput['getActivePlatforms']): Promise<import("../types").WebResponse<string[]>>;
-    getPlatformWorkerStats<P extends AllPlatforms>({ auth, platform }: PlatformFunctionsInput<P>['getPlatformWorkerStats']): Promise<import("../types").WebResponse<PlatformStats>>;
+    getActivePlatforms({ auth }: PlatformFunctionsInput['getActivePlatforms']): Promise<import("../types").WebResponse<AllPlatforms[]>>;
+    getPlatformWorkerStats<P extends AllPlatforms>({ auth, platform, page, limit }: PlatformFunctionsInput<P>['getPlatformWorkerStats']): Promise<import("../types").WebResponse<PlatformStats>>;
     getGuildsForStreamer<P extends AllPlatforms>({ auth, platform, username }: PlatformFunctionsInput<P>['getGuildsForStreamer']): Promise<import("../types").WebResponse<GuildsForStreamer>>;
 }
 export type PlatformFunctionsInput<P extends AllPlatforms = never> = {
@@ -15,6 +15,8 @@ export type PlatformFunctionsInput<P extends AllPlatforms = never> = {
     'getPlatformWorkerStats': {
         auth: string;
         platform: P;
+        page?: number;
+        limit?: number;
     };
     'getGuildsForStreamer': {
         auth: string;
@@ -31,7 +33,10 @@ export type PlatformReturnTypes = {
     'getGuildsForStreamerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPlatform['getGuildsForStreamer']>>>;
 };
 export type PlatformStats = {
-    monitoredUsernames: string[];
+    monitoredUsernames: {
+        username: string;
+        isLive: boolean | null;
+    }[];
     status: 'online' | 'offline';
     lastUpdated: number;
     workerId: number;

package/dist/classes/platform.js

@@ -14,10 +14,13 @@ class APIPlatform {
             endpoint: this.web.qp('/data/platforms'),
         });
     }
-    async getPlatformWorkerStats({ auth, platform }) {
+    async getPlatformWorkerStats({ auth, platform, page, limit }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp('/data/platforms/' + platform),
+            endpoint: this.web.qp('/data/platforms/' + platform, {
+                page: page,
+                limit: limit,
+            }),
         });
     }
     async getGuildsForStreamer({ auth, platform, username }) {

package/dist/classes/premium.d.ts

@@ -10,12 +10,13 @@ export declare class APIPremium {
     getPremiumPlans({ refreshCache }: PremiumFunctionsInput['getPremiumPlans']): Promise<import("../types").WebResponse<PremiumPlans>>;
     getPremiumPlan<T extends boolean>({ planId, includeFreeAmountOfAddons }: PremiumFunctionsInput<never, T>['getPremiumPlan']): Promise<import("../types").WebResponse<PremiumPlan<T>>>;
     createCheckoutSession<T extends 'guild' | 'user'>({ auth, body, type }: PremiumFunctionsInput<T>['createCheckoutSession']): Promise<import("../types").WebResponse<string>>;
-    getAllUserSubscriptions({ auth }: PremiumFunctionsInput<never>['getAllUserSubscriptions']): Promise<import("../types").WebResponse<AllSubscriptions>>;
+    getAllUserSubscriptions({ auth, force }: PremiumFunctionsInput<never>['getAllUserSubscriptions']): Promise<import("../types").WebResponse<AllSubscriptions>>;
     changePaymentMethods({ auth }: PremiumFunctionsInput<never>['changePaymentMethods']): Promise<import("../types").WebResponse<string>>;
     changeSubscriptionTier({ auth, body }: PremiumFunctionsInput<never>['changeSubscriptionTier']): Promise<import("../types").WebResponse<string>>;
     changeSubscriptionAddons({ auth, body }: PremiumFunctionsInput<never>['changeSubscriptionAddons']): Promise<import("../types").WebResponse<string>>;
-    cancelSubscription({ auth, subscriptionId }: PremiumFunctionsInput<never>['cancelSubscription']): Promise<import("../types").WebResponse<string>>;
+    cancelSubscription({ auth, subscriptionId, immediately }: PremiumFunctionsInput<never>['cancelSubscription']): Promise<import("../types").WebResponse<string>>;
     syncStripeSubscriptions({ auth }: PremiumFunctionsInput<never>['syncStripeSubscriptions']): Promise<import("../types").WebResponse<SyncSubscriptionsResponse>>;
+    adjustCustomerBalance({ auth, body }: PremiumFunctionsInput['adjustCustomerBalance']): Promise<import("../types").WebResponse<AdjustCustomerBalanceResponse>>;
 }
 export type PremiumFunctionsInput<T extends 'guild' | 'user' = never, I extends boolean = never> = {
     'getPremumData': {
@@ -43,6 +44,7 @@ export type PremiumFunctionsInput<T extends 'guild' | 'user' = never, I extends
     };
     'getAllUserSubscriptions': {
         auth: string;
+        force?: boolean;
     };
     'changePaymentMethods': {
         auth: string;
@@ -58,10 +60,15 @@ export type PremiumFunctionsInput<T extends 'guild' | 'user' = never, I extends
     'cancelSubscription': {
         auth: string;
         subscriptionId: string;
+        immediately?: boolean;
     };
     'syncStripeSubscriptions': {
         auth: string;
     };
+    'adjustCustomerBalance': {
+        auth: string;
+        body: AdjustCustomerBalanceBody;
+    };
 };
 export type PremiumReturnTypes = {
     'getPremumDataRaw': Awaited<ReturnType<APIPremium['getPremumData']>>;
@@ -86,6 +93,8 @@ export type PremiumReturnTypes = {
     'cancelSubscriptionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['cancelSubscription']>>>;
     'syncStripeSubscriptionsRaw': Awaited<ReturnType<APIPremium['syncStripeSubscriptions']>>;
     'syncStripeSubscriptionsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['syncStripeSubscriptions']>>>;
+    'adjustCustomerBalanceRaw': Awaited<ReturnType<APIPremium['adjustCustomerBalance']>>;
+    'adjustCustomerBalanceSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['adjustCustomerBalance']>>>;
 };
 export type CreateCheckoutSessionBody<T extends 'guild' | 'user'> = T extends 'guild' ? {
     email: string;
@@ -115,6 +124,14 @@ export type PremiumPlans = {
         addonId: string;
         priceCents: number;
         isActive: boolean;
+        currency: string;
+    }[];
+    addonMetadata: {
+        addonId: string;
+        name: string;
+        priceCents: number;
+        isBoolean: boolean;
+        isActive: boolean;
     }[];
 };
 export type PortalData = {
@@ -131,10 +148,12 @@ export type PremiumPlan<T extends boolean> = T extends true ? PremiumPlanType &
 } : PremiumPlanType;
 export type UpdatePremiumData<T extends 'guild' | 'user'> = T extends 'guild' ? {
     newPlanId?: string;
-    newBitfield?: string;
-    overrideBranding?: boolean;
+    newBitfield?: string | null;
+    overrideBranding?: boolean | null;
+    vodDownloadStoreForHours?: number | null;
 } & ListOfDefaultItems : T extends 'user' ? {
-    newPlanId: string;
+    newPlanId?: string;
+    newBitfield?: string | null;
 } : never;
 export type ListOfDefaultItems = Partial<Omit<NonNullable<DeepRequired<Guild>['premium']>, 'tier' | 'enabled' | 'dbId' | 'guildId'>>;
 export type RemoveAdditional<T> = T extends `additional${infer Rest}` ? Rest : T;
@@ -145,8 +164,9 @@ export type SliceAdditionalFromItem = {
 export type PremiumData<T extends 'guild' | 'user'> = T extends 'guild' ? {
     bitfield: Guild['bitfield'];
     premium: Guild['premium'];
-    overrideBranding: Guild['overrideBranding'];
     freeTierInfo: SliceAdditionalFromItem;
+    vodDownloadStoreForHours: Guild['vodDownloadStoreForHours'];
+    overrideBranding: Guild['overrideBranding'];
 } : T extends 'user' ? {
     badges: User['badges'];
     bitfield: User['bitfield'];
@@ -171,11 +191,34 @@ export type AllSubscriptions = {
     guilds: (PremiumSubscription & {
         guildId: string;
     })[];
+    unpaidInvoices: {
+        id: string;
+        amountDueCents: number;
+        amountPaidCents: number;
+        status: string | null;
+        dueDate: string | null;
+        url: string | null;
+        createdAt: string;
+    }[];
 };
 export type ChangeSubscriptionTierBody = {
     subscriptionId: string;
     newTierId: string;
 };
+export type AdjustCustomerBalanceBody = {
+    customerId: string;
+    balanceAdjustmentCents: number;
+    reason: string;
+};
+export type AdjustCustomerBalanceResponse = {
+    success: true;
+    customerId: string;
+    previousBalance: number;
+    newBalance: number;
+    adjustment: number;
+    reason: string;
+    timestamp: string;
+};
 export type ChangeSubscriptionAddonsBody = {
     subscriptionId: string;
     newAddons: {
@@ -187,9 +230,9 @@ export type SyncSubscriptionsResponse = {
     status: 200;
     message: string;
     synced: number;
-    created: number;
-    updated: number;
-    alreadyCorrect: number;
+    created?: number;
+    updated?: number;
+    alreadyCorrect?: number;
     errors?: Array<{
         guildId: string;
         subscriptionId: string;

package/dist/classes/premium.js

@@ -42,10 +42,12 @@ class APIPremium {
             endpoint: this.web.qp('/stripe/sessions/' + type),
         });
     }
-    async getAllUserSubscriptions({ auth }) {
+    async getAllUserSubscriptions({ auth, force }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp('/stripe/subscriptions'),
+            endpoint: this.web.qp('/stripe/subscriptions', {
+                force: force || false,
+            }),
         });
     }
     async changePaymentMethods({ auth }) {
@@ -66,10 +68,12 @@ class APIPremium {
             endpoint: this.web.qp('/stripe/subscriptions/addons'),
         });
     }
-    async cancelSubscription({ auth, subscriptionId }) {
+    async cancelSubscription({ auth, subscriptionId, immediately }) {
         return await this.web.request({
             method: 'DELETE', auth,
-            endpoint: this.web.qp('/stripe/subscriptions/' + subscriptionId),
+            endpoint: this.web.qp('/stripe/subscriptions/' + subscriptionId, {
+                immediately: immediately || false,
+            }),
         });
     }
     async syncStripeSubscriptions({ auth }) {
@@ -78,5 +82,11 @@ class APIPremium {
             endpoint: this.web.qp('/stripe/sync-subscriptions'),
         });
     }
+    async adjustCustomerBalance({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/support/customer-balance'),
+        });
+    }
 }
 exports.APIPremium = APIPremium;

package/dist/classes/sessions.d.ts

@@ -5,7 +5,7 @@ export declare class APISessions {
     private web;
     constructor(web: WebDataManager);
     checkSession({ auth }: SessionsFunctionsInput['checkSession']): Promise<import("../types").WebResponse<boolean>>;
-    postSession({ code, auth, addToServer }: SessionsFunctionsInput['postSession']): Promise<import("../types").WebResponse<SessionPostReturnType>>;
+    postSession({ code, auth, addToServer, state }: SessionsFunctionsInput['postSession']): Promise<import("../types").WebResponse<SessionPostReturnType>>;
     deleteSession({ auth }: SessionsFunctionsInput['deleteSession']): Promise<import("../types").WebResponse<true>>;
 }
 export type SessionsFunctionsInput = {
@@ -16,6 +16,7 @@ export type SessionsFunctionsInput = {
         code: string;
         auth: string;
         addToServer?: boolean;
+        state?: string;
     };
     'deleteSession': {
         auth: string;

package/dist/classes/sessions.js

@@ -14,11 +14,12 @@ class APISessions {
             endpoint: this.web.qp('/sessions'),
         });
     }
-    async postSession({ code, auth, addToServer }) {
+    async postSession({ code, auth, addToServer, state }) {
         return await this.web.request({
             method: 'POST', auth,
             endpoint: this.web.qp('/sessions', {
                 code,
+                state,
                 add: addToServer || true,
             }),
         });

package/dist/classes/teams.d.ts

@@ -1,17 +1,17 @@
+import { CancelOutWebResponses, DeepPartial } from '../types';
+import { Team, TeamZod } from '../other/prisma';
 import { WebDataManager } from '../core/manager';
-import { CancelOutWebResponses } from '../types';
-import { Team } from '../other/prisma';
 export declare class APITeams {
     private web;
     constructor(web: WebDataManager);
     getAllUserTeams({ auth }: TeamsFunctionsInput['getAllUserTeams']): Promise<import("../types").WebResponse<TeamsGetType>>;
-    createTeam({ auth, teamName }: TeamsFunctionsInput['createTeam']): Promise<import("../types").WebResponse<string>>;
+    createTeam({ auth, team }: TeamsFunctionsInput['createTeam']): Promise<import("../types").WebResponse<string>>;
     joinOrLeaveTeam({ auth, teamOrCode, action }: TeamsFunctionsInput['joinOrLeaveTeam']): Promise<import("../types").WebResponse<string>>;
     createTeamInvite({ auth, teamId, maxUses, bitfieldToSet, expiresAt }: TeamsFunctionsInput['createTeamInvite']): Promise<import("../types").WebResponse<string>>;
     kickTeamMember({ auth, teamId, userId }: TeamsFunctionsInput['kickTeamMember']): Promise<import("../types").WebResponse<string>>;
     updateMemberPermissions({ auth, teamId, userId, bitfieldToSet }: TeamsFunctionsInput['updateMemberPermissions']): Promise<import("../types").WebResponse<string>>;
-    updateTeamName({ auth, teamId, teamName }: TeamsFunctionsInput['updateTeamName']): Promise<import("../types").WebResponse<string>>;
-    deleteTeam({ auth, teamId }: TeamsFunctionsInput['updateTeamName']): Promise<import("../types").WebResponse<string>>;
+    updateTeam({ auth, teamId, team }: TeamsFunctionsInput['updateTeam']): Promise<import("../types").WebResponse<string>>;
+    deleteTeam({ auth, teamId }: TeamsFunctionsInput['deleteTeam']): Promise<import("../types").WebResponse<string>>;
 }
 export type TeamsFunctionsInput = {
     'getAllUserTeams': {
@@ -19,7 +19,7 @@ export type TeamsFunctionsInput = {
     };
     'createTeam': {
         auth: string;
-        teamName: string;
+        team: DeepPartial<TeamZod>;
     };
     'joinOrLeaveTeam': {
         auth: string;
@@ -29,9 +29,9 @@ export type TeamsFunctionsInput = {
     'createTeamInvite': {
         auth: string;
         teamId: string;
-        maxUses: number;
         bitfieldToSet: string;
-        expiresAt: number;
+        maxUses?: number;
+        expiresAt?: number;
     };
     'kickTeamMember': {
         auth: string;
@@ -44,10 +44,10 @@ export type TeamsFunctionsInput = {
         userId: string;
         bitfieldToSet: string;
     };
-    'updateTeamName': {
+    'updateTeam': {
         auth: string;
         teamId: string;
-        teamName: string;
+        team: DeepPartial<TeamZod>;
     };
     'deleteTeam': {
         auth: string;
@@ -67,18 +67,23 @@ export type TeamsGetReturnTypes = {
     'kickTeamMemberSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['kickTeamMember']>>>;
     'updateMemberPermissionsRaw': Awaited<ReturnType<APITeams['updateMemberPermissions']>>;
     'updateMemberPermissionsSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['updateMemberPermissions']>>>;
-    'updateTeamNameRaw': Awaited<ReturnType<APITeams['updateTeamName']>>;
-    'updateTeamNameSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['updateTeamName']>>>;
+    'updateTeamRaw': Awaited<ReturnType<APITeams['updateTeam']>>;
+    'updateTeamSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['updateTeam']>>>;
     'deleteTeamRaw': Awaited<ReturnType<APITeams['deleteTeam']>>;
     'deleteTeamSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['deleteTeam']>>>;
 };
+export type TeamInviteBody = {
+    bitfieldToSet: string;
+    maxUses?: number;
+    expiresAt?: number;
+};
 export type TeamsGetType = {
-    managedTeam: Team & {
+    managedTeam: (Team & {
         teamMembers: (Team['teamMembers'][number] & {
             username: string | null;
             kickUsername: string | null;
         })[];
-    };
+    }) | null;
     memberTeams: {
         teamId: string;
         teamName: string;

package/dist/classes/teams.js

@@ -14,11 +14,10 @@ class APITeams {
             endpoint: this.web.qp('/data/teams'),
         });
     }
-    async createTeam({ auth, teamName }) {
+    async createTeam({ auth, team }) {
         return await this.web.request({
-            method: 'POST', auth,
+            method: 'POST', auth, body: team,
             endpoint: this.web.qp('/data/teams'),
-            body: { teamName },
         });
     }
     async joinOrLeaveTeam({ auth, teamOrCode, action }) {
@@ -31,29 +30,28 @@ class APITeams {
     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 },
+            endpoint: this.web.qp(`/data/teams/${teamId}/invite`),
         });
     }
     async kickTeamMember({ auth, teamId, userId }) {
         return await this.web.request({
             method: 'PUT', auth,
-            endpoint: this.web.qp(`/data/teams/${teamId}/kick`),
             body: { userId },
+            endpoint: this.web.qp(`/data/teams/${teamId}/kick`),
         });
     }
     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 },
+            endpoint: this.web.qp(`/data/teams/${teamId}/update`),
         });
     }
-    async updateTeamName({ auth, teamId, teamName }) {
+    async updateTeam({ auth, teamId, team }) {
         return await this.web.request({
-            method: 'PATCH', auth,
+            method: 'PATCH', auth, body: team,
             endpoint: this.web.qp(`/data/teams/${teamId}`),
-            body: { teamName },
         });
     }
     async deleteTeam({ auth, teamId }) {

package/dist/classes/user.d.ts

@@ -7,7 +7,7 @@ export declare class APIUser {
     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>>;
+    deleteUser({ auth, userId }: UserFunctionsInput['deleteUser']): Promise<import("../types").WebResponse<string>>;
 }
 export type UserFunctionsInput = {
     'getUser': {

package/dist/classes/vods.d.ts

@@ -25,7 +25,7 @@ export type VodsFunctionsInput = {
         fileKey: string;
     };
 };
-export type R2ReturnTypes = {
+export type VodsReturnTypes = {
     'getTotalFilesRaw': Awaited<ReturnType<APIVods['getTotalFiles']>>;
     'getTotalFilesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIVods['getTotalFiles']>>>;
     'getGuildFileVodDataRaw': Awaited<ReturnType<APIVods['getGuildFileVodData']>>;
@@ -42,14 +42,20 @@ export type VodResponse = {
 export type VodGuildFileData = {
     guildId: string;
     allowedUntil: Date;
+    thumbnail: string | null;
     tempUrl: string;
 };
+export type VodAllowedGuild = {
+    guildId: string;
+    allowedUntil: Date | null;
+};
 export type VodFileData = {
     key: string;
     contentType?: string;
     contentLength?: number;
     lastModified?: number;
     expiresAt?: string;
-    allowedGuilds: string[];
+    allowedGuilds: VodAllowedGuild[];
+    thumbnail: string | null;
     tempUrl: string;
 };

package/dist/other/zod/guild.zod.d.ts

@@ -42,6 +42,9 @@ export declare const GuildZod: {
         }, z.core.$strip>>>;
         birthdayRoleId: z.ZodNullable<z.ZodString>;
         birthdayChannelId: z.ZodNullable<z.ZodString>;
+        birthdayPanelChannelId: z.ZodNullable<z.ZodString>;
+        birthdayPanelMessageId: z.ZodNullable<z.ZodString>;
+        birthdayPanelDuration: z.ZodNullable<z.ZodString>;
         welcomeChannelId: z.ZodNullable<z.ZodString>;
         leaveChannelId: z.ZodNullable<z.ZodString>;
         birthdayEnabled: z.ZodNullable<z.ZodBoolean>;

package/dist/other/zod/guild.zod.js

@@ -15,6 +15,9 @@ const GuildSchema = zod_2.z.object({
     disableBranding: zod_2.z.lazy(() => GuildDisableBrandingSchema).nullable(),
     birthdayRoleId: zod_1.SnowFlake.nullable(),
     birthdayChannelId: zod_1.SnowFlake.nullable(),
+    birthdayPanelChannelId: zod_1.SnowFlake.nullable(),
+    birthdayPanelMessageId: zod_1.SnowFlake.nullable(),
+    birthdayPanelDuration: zod_2.z.string().nullable(),
     welcomeChannelId: zod_1.SnowFlake.nullable(),
     leaveChannelId: zod_1.SnowFlake.nullable(),
     birthdayEnabled: zod_2.z.boolean().nullable(),

package/dist/other/zod/r2Storage.zod.d.ts

@@ -10,6 +10,7 @@ export declare const R2StorageZod: {
         tempUrl: z.ZodNullable<z.ZodString>;
         urlExpiresAt: z.ZodNullable<z.ZodDate>;
         thumbnail: z.ZodNullable<z.ZodString>;
+        title: z.ZodNullable<z.ZodString>;
         streamDate: z.ZodNullable<z.ZodDate>;
         guilds: z.ZodArray<z.ZodLazy<z.ZodObject<{
             guildId: z.ZodString;

package/dist/other/zod/r2Storage.zod.js

@@ -9,6 +9,7 @@ const R2StorageSchema = zod_2.z.object({
     tempUrl: zod_2.z.string().nullable(),
     urlExpiresAt: zod_2.z.date().nullable(),
     thumbnail: zod_2.z.string().nullable(),
+    title: zod_2.z.string().nullable(),
     streamDate: zod_2.z.date().nullable(),
     guilds: (0, zod_1.NoDuplicate)(zod_2.z.array(zod_2.z.lazy(() => R2StorageGuildSchema)), ['guildId']),
 });

package/dist/other/zod/rumbleStreamer.zod.d.ts

@@ -9,8 +9,8 @@ export declare const RumbleStreamerZod: {
         streamerUserName: z.ZodString;
         guildId: z.ZodString;
         type: z.ZodEnum<{
-            user: "user";
             channel: "channel";
+            user: "user";
         }>;
         deleteEmbeds: z.ZodNullable<z.ZodBoolean>;
         sendOfflineMessage: z.ZodNullable<z.ZodBoolean>;

package/dist/other/zod/youtubeStreamer.zod.d.ts

@@ -63,6 +63,7 @@ export declare const YoutubeStreamerZod: {
         videoNotificationChannelId: z.ZodNullable<z.ZodString>;
         showNotifyButton: z.ZodNullable<z.ZodBoolean>;
         pingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
+        videoRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
         customCoolDownBeforeNextLive: z.ZodNullable<z.ZodNumber>;
         liveRoleId: z.ZodNullable<z.ZodString>;
         usersForLiveRole: z.ZodArray<z.ZodString>;

package/dist/other/zod/youtubeStreamer.zod.js

@@ -17,6 +17,7 @@ const YoutubeStreamerSchema = zod_2.z.object({
     videoNotificationChannelId: zod_1.SnowFlake.nullable(),
     showNotifyButton: zod_2.z.boolean().nullable(),
     pingRoleId: zod_1.SnowFlakeOrEveryone.nullable(),
+    videoRoleId: zod_1.SnowFlakeOrEveryone.nullable(),
     customCoolDownBeforeNextLive: zod_2.z.number().min(0).max(360).nullable(),
     liveRoleId: zod_1.SnowFlake.nullable(),
     usersForLiveRole: (0, zod_1.NoDuplicate)(zod_2.z.array(zod_1.SnowFlake)),