@notidotbot/noti-api-client 1.4.0

package/dist/classes/platform.d.ts

@@ -0,0 +1,227 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses } from '../types';
+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>>;
+    getGuildsForStreamer<P extends AllPlatforms>({ auth, platform, username }: PlatformFunctionsInput<P>['getGuildsForStreamer']): Promise<import("../types").WebResponse<GuildsForStreamer>>;
+}
+export type PlatformFunctionsInput<P extends AllPlatforms = never> = {
+    'getActivePlatforms': {
+        auth: string;
+    };
+    'getPlatformWorkerStats': {
+        auth: string;
+        platform: P;
+    };
+    'getGuildsForStreamer': {
+        auth: string;
+        platform: P;
+        username: string;
+    };
+};
+export type PlatformReturnTypes = {
+    'getActivePlatformsRaw': Awaited<ReturnType<APIPlatform['getActivePlatforms']>>;
+    'getActivePlatformsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPlatform['getActivePlatforms']>>>;
+    'getPlatformWorkerStatsRaw': Awaited<ReturnType<APIPlatform['getPlatformWorkerStats']>>;
+    'getPlatformWorkerStatsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPlatform['getPlatformWorkerStats']>>>;
+    'getGuildsForStreamerRaw': Awaited<ReturnType<APIPlatform['getGuildsForStreamer']>>;
+    'getGuildsForStreamerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPlatform['getGuildsForStreamer']>>>;
+};
+export type PlatformStats = {
+    monitoredUsernames: string[];
+    status: 'online' | 'offline';
+    lastUpdated: number;
+    workerId: number;
+}[];
+export type GuildsForStreamer = {
+    streamerUsername: string;
+    guilds: string[];
+};
+export type PlatformUser<T extends AllPlatforms> = T extends 'kick' ? KickStreamerRaw : T extends 'twitch' ? TwitchStreamerRaw : T extends 'rumble' ? RumbleStreamerRaw : T extends 'tiktok' ? TikTokStreamerRaw : never;
+export type KickStreamerRaw = {
+    id: number;
+    user_id: number;
+    slug: string;
+    is_banned: boolean;
+    playback_url: string;
+    vod_enabled: boolean;
+    subscription_enabled: boolean;
+    followers_count: number;
+    subscriber_badges: {
+        id: number;
+        channel_id: number;
+        months: number;
+        badge_image: {
+            srcset: string;
+            src: string;
+        };
+    }[];
+    banner_image?: {
+        url: string;
+    };
+    livestream?: {
+        id: number;
+        slug: string;
+        channel_id: number;
+        created_at: string;
+        session_title: string;
+        is_live: boolean;
+        risk_level_id: unknown;
+        source: unknown;
+        twitch_channel: unknown;
+        duration: number;
+        language: string;
+        is_mature: boolean;
+        viewer_count: number;
+        thumbnail?: {
+            url: string;
+        };
+        categories: {
+            id: number;
+            category_id: number;
+            name: string;
+            slug: string;
+            tags: string[];
+            description: unknown;
+            deleted_at: unknown;
+            viewers: number;
+            category: {
+                id: number;
+                name: string;
+                slug: string;
+                icon: string;
+            };
+        }[];
+        tags: unknown[];
+    } | null;
+    role: string;
+    muted: boolean;
+    follower_badges: unknown[];
+    offline_banner_image: string;
+    verified: boolean;
+    recent_categories: {
+        id: number;
+        category_id: number;
+        name: string;
+        slug: string;
+        tags: string[];
+        description: string;
+        deleted_at: unknown;
+        viewers: number;
+        banner: {
+            responsive: string;
+            url: string;
+        };
+        category: {
+            id: number;
+            name: string;
+            slug: string;
+            icon: string;
+        };
+    }[];
+    can_host: boolean;
+    user: {
+        id: number;
+        username: string;
+        agreed_to_terms: boolean;
+        email_verified_at: string;
+        bio: string;
+        country: string;
+        state: string;
+        city: string;
+        instagram: string;
+        twitter: string;
+        youtube: string;
+        discord: string;
+        tiktok: string;
+        facebook: string;
+        profile_pic: string;
+    };
+    chatroom: {
+        id: number;
+        chatable_type: string;
+        channel_id: number;
+        created_at: string;
+        updated_at: string;
+        chat_mode_old: string;
+        chat_mode: string;
+        slow_mode: boolean;
+        chatable_id: number;
+        followers_mode: boolean;
+        subscribers_mode: boolean;
+        emotes_mode: boolean;
+        message_interval: number;
+        following_min_duration: number;
+    };
+};
+export type TwitchStreamerRaw = {
+    id: string;
+    login: string;
+    display_name: string;
+    description: string;
+    type: 'staff' | 'admin' | 'global_mod' | '';
+    broadcaster_type: 'partner' | 'affiliate' | '';
+    profile_image_url: string;
+    offline_image_url: string;
+    view_count: number;
+    created_at: string;
+};
+export type RumbleStreamerRaw = {
+    name: string;
+    followers: number;
+    verified: boolean;
+    pfp: string | null;
+    isLive: boolean;
+    liveStream: {
+        title: string;
+        views: number;
+    } | null;
+};
+export type TikTokStreamerRaw = {
+    liveData?: {
+        coverUrl: string;
+        liveSubOnly: number;
+        startTime: number;
+        streamId: string;
+        title: string;
+        stats?: {
+            followerCount: number;
+            followingCount: number;
+        };
+        user?: {
+            avatarLarger: string;
+            avatarMedium: string;
+            avatarThumb: string;
+            id: string;
+            nickname: string;
+            roomId: string;
+            secUid: string;
+            secret: boolean;
+            signature: string;
+            uniqueId: string;
+            verified: boolean;
+        };
+    } | null;
+    userData: {
+        avatarLarger: string;
+        avatarMedium: string;
+        avatarThumb: string;
+        nickname: string;
+        openFavorite: boolean;
+        privateAccount: boolean;
+        secret: boolean;
+        signature: string;
+        uniqueId: string;
+        verified: boolean;
+        stats: {
+            followerCount: number;
+            followingCount: number;
+            friendCount: number;
+            heartCount: number;
+            videoCount: number;
+        };
+    };
+};

package/dist/classes/platform.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIPlatform = void 0;
+// Data.
+class APIPlatform {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getActivePlatforms({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/platforms'),
+        });
+    }
+    async getPlatformWorkerStats({ auth, platform }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/platforms/' + platform),
+        });
+    }
+    async getGuildsForStreamer({ auth, platform, username }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/data/platforms/' + platform + '/' + username),
+        });
+    }
+}
+exports.APIPlatform = APIPlatform;

package/dist/classes/premium.d.ts

@@ -0,0 +1,179 @@
+import { CancelOutWebResponses, DeepRequired } from '../types';
+import { WebDataManager } from '../core/manager';
+import { PremiumPlanType } from '../other/types';
+import { Guild, User } from '../other/prisma';
+export declare class APIPremium {
+    private web;
+    constructor(web: WebDataManager);
+    getPremumData<T extends 'guild' | 'user' = never>({ auth, type, id }: PremiumFunctionsInput<T>['getPremumData']): Promise<import("../types").WebResponse<PremiumData<T>>>;
+    changePremiumData<T extends 'guild' | 'user' = never>({ auth, type, id, body }: PremiumFunctionsInput<T>['changePremiumData']): Promise<import("../types").WebResponse<true>>;
+    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>>;
+    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>>;
+}
+export type PremiumFunctionsInput<T extends 'guild' | 'user' = never, I extends boolean = never> = {
+    'getPremumData': {
+        auth: string;
+        type: T;
+        id: string;
+    };
+    'changePremiumData': {
+        auth: string;
+        type: T;
+        id: string;
+        body: UpdatePremiumData<T>;
+    };
+    'getPremiumPlans': {
+        refreshCache?: boolean;
+    };
+    'getPremiumPlan': {
+        planId: string;
+        includeFreeAmountOfAddons?: I;
+    };
+    'createCheckoutSession': {
+        auth: string;
+        body: CreateCheckoutSessionBody<T>;
+        type: T;
+    };
+    'getAllUserSubscriptions': {
+        auth: string;
+    };
+    'changePaymentMethods': {
+        auth: string;
+    };
+    'changeSubscriptionTier': {
+        auth: string;
+        body: ChangeSubscriptionTierBody;
+    };
+    'changeSubscriptionAddons': {
+        auth: string;
+        body: ChangeSubscriptionAddonsBody;
+    };
+    'cancelSubscription': {
+        auth: string;
+        subscriptionId: string;
+    };
+};
+export type PremiumReturnTypes = {
+    'getPremumDataRaw': Awaited<ReturnType<APIPremium['getPremumData']>>;
+    'getPremumDataSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['getPremumData']>>>;
+    'changePremiumDataRaw': Awaited<ReturnType<APIPremium['changePremiumData']>>;
+    'changePremiumDataSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['changePremiumData']>>>;
+    'getPremiumPlansRaw': Awaited<ReturnType<APIPremium['getPremiumPlans']>>;
+    'getPremiumPlansSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['getPremiumPlans']>>>;
+    'getPremiumPlanRaw': Awaited<ReturnType<APIPremium['getPremiumPlan']>>;
+    'getPremiumPlanSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['getPremiumPlan']>>>;
+    'createCheckoutSessionRaw': Awaited<ReturnType<APIPremium['createCheckoutSession']>>;
+    'createCheckoutSessionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['createCheckoutSession']>>>;
+    'getAllUserSubscriptionsRaw': Awaited<ReturnType<APIPremium['getAllUserSubscriptions']>>;
+    'getAllUserSubscriptionsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['getAllUserSubscriptions']>>>;
+    'changePaymentMethodsRaw': Awaited<ReturnType<APIPremium['changePaymentMethods']>>;
+    'changePaymentMethodsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['changePaymentMethods']>>>;
+    'changeSubscriptionTierRaw': Awaited<ReturnType<APIPremium['changeSubscriptionTier']>>;
+    'changeSubscriptionTierSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['changeSubscriptionTier']>>>;
+    'changeSubscriptionAddonsRaw': Awaited<ReturnType<APIPremium['changeSubscriptionAddons']>>;
+    'changeSubscriptionAddonsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['changeSubscriptionAddons']>>>;
+    'cancelSubscriptionRaw': Awaited<ReturnType<APIPremium['cancelSubscription']>>;
+    'cancelSubscriptionSuccess': CancelOutWebResponses<Awaited<ReturnType<APIPremium['cancelSubscription']>>>;
+};
+export type CreateCheckoutSessionBody<T extends 'guild' | 'user'> = T extends 'guild' ? {
+    email: string;
+    userId: string;
+    annual?: boolean;
+    guildId: string;
+    subscriptionTierId: string;
+    affiliate?: string;
+    trialDays?: number;
+} & ListOfDefaultItems : T extends 'user' ? {
+    email: string;
+    userId: string;
+    annual?: boolean;
+    subscriptionTierId: string;
+    affiliate?: string;
+    trialDays?: number;
+} : never;
+export type OneTimePaymentUrlBody = {
+    cents: number;
+    metadata: Record<string, string>;
+} & UserData;
+export type PremiumPlans = {
+    tiers: PremiumPlanType[];
+    addons: {
+        type: 'guild' | 'user';
+        name: string;
+        addonId: string;
+        priceCents: number;
+        isActive: boolean;
+    }[];
+};
+export type PortalData = {
+    intention?: 'subscription_cancel' | 'payment_method_update';
+} & UserData;
+export type UserData = {
+    email: string;
+    userId: string;
+} | {
+    customerId: string;
+};
+export type PremiumPlan<T extends boolean> = T extends true ? PremiumPlanType & {
+    freeTierInfo: SliceAdditionalFromItem;
+} : PremiumPlanType;
+export type UpdatePremiumData<T extends 'guild' | 'user'> = T extends 'guild' ? {
+    newPlanId?: string;
+    newBitfield?: string;
+    overrideBranding?: boolean;
+} & ListOfDefaultItems : T extends 'user' ? {
+    newPlanId: string;
+} : 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;
+export type JoinWithDefault<T> = T extends string ? `default${T}` : never;
+export type SliceAdditionalFromItem = {
+    [K in keyof ListOfDefaultItems as K extends string ? JoinWithDefault<RemoveAdditional<K>> : never]: ListOfDefaultItems[K];
+};
+export type PremiumData<T extends 'guild' | 'user'> = T extends 'guild' ? {
+    bitfield: Guild['bitfield'];
+    premium: Guild['premium'];
+    overrideBranding: Guild['overrideBranding'];
+    freeTierInfo: SliceAdditionalFromItem;
+} : T extends 'user' ? {
+    badges: User['badges'];
+    bitfield: User['bitfield'];
+    premium: User['premium'];
+    oneServerPremium: User['oneServerPremium'];
+    serverPremiumCooldown: User['serverPremiumCooldown'];
+} : never;
+export type PremiumSubscription = {
+    id: string;
+    title: string | null;
+    isAnnual: boolean;
+    tierId: string | undefined;
+    status: 'active' | 'canceled' | 'incomplete' | 'incomplete_expired' | 'past_due' | 'paused' | 'trialing' | 'unpaid';
+    endedAt: Date | null;
+    periodEnd: Date;
+    canceledAt: Date | null;
+    trialEndsAt: Date | null;
+    priceCents: number;
+};
+export type AllSubscriptions = {
+    user: PremiumSubscription | null;
+    guilds: (PremiumSubscription & {
+        guildId: string;
+    })[];
+};
+export type ChangeSubscriptionTierBody = {
+    subscriptionId: string;
+    newTierId: string;
+};
+export type ChangeSubscriptionAddonsBody = {
+    subscriptionId: string;
+    newAddons: {
+        addonId: string;
+        quantity: number;
+    }[];
+};

package/dist/classes/premium.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIPremium = void 0;
+// Data.
+class APIPremium {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getPremumData({ auth, type, id }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/premium/manage/' + type + '/' + id),
+        });
+    }
+    async changePremiumData({ auth, type, id, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/premium/manage/' + type + '/' + id),
+        });
+    }
+    async getPremiumPlans({ refreshCache }) {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/premium/plans', {
+                all: refreshCache || false,
+            }),
+        });
+    }
+    async getPremiumPlan({ planId, includeFreeAmountOfAddons }) {
+        return await this.web.request({
+            method: 'GET',
+            endpoint: this.web.qp('/premium/plans/' + planId, {
+                ifcd: includeFreeAmountOfAddons || false,
+            }),
+        });
+    }
+    async createCheckoutSession({ auth, body, type }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/stripe/sessions/' + type),
+        });
+    }
+    async getAllUserSubscriptions({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/stripe/subscriptions'),
+        });
+    }
+    async changePaymentMethods({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/stripe/payments'),
+        });
+    }
+    async changeSubscriptionTier({ auth, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/stripe/subscriptions/tier'),
+        });
+    }
+    async changeSubscriptionAddons({ auth, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp('/stripe/subscriptions/addons'),
+        });
+    }
+    async cancelSubscription({ auth, subscriptionId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/stripe/subscriptions/' + subscriptionId),
+        });
+    }
+}
+exports.APIPremium = APIPremium;

package/dist/classes/sessions.d.ts

@@ -0,0 +1,42 @@
+import { CancelOutWebResponses } from '../types';
+import { WebDataManager } from '../core/manager';
+import { CurrentUser } from './@me';
+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>>;
+    deleteSession({ auth }: SessionsFunctionsInput['deleteSession']): Promise<import("../types").WebResponse<true>>;
+}
+export type SessionsFunctionsInput = {
+    'checkSession': {
+        auth: string;
+    };
+    'postSession': {
+        code: string;
+        auth: string;
+        addToServer?: boolean;
+    };
+    'deleteSession': {
+        auth: string;
+    };
+};
+export type SessionsReturnTypes = {
+    'checkSessionRaw': Awaited<ReturnType<APISessions['checkSession']>>;
+    'checkSessionSuccess': CancelOutWebResponses<Awaited<ReturnType<APISessions['checkSession']>>>;
+    'postSessionRaw': Awaited<ReturnType<APISessions['postSession']>>;
+    'postSessionSuccess': CancelOutWebResponses<Awaited<ReturnType<APISessions['postSession']>>>;
+    'deleteSessionRaw': Awaited<ReturnType<APISessions['deleteSession']>>;
+    'deleteSessionSuccess': CancelOutWebResponses<Awaited<ReturnType<APISessions['deleteSession']>>>;
+};
+export type SessionPostReturnType = {
+    customToken: string;
+    guilds: {
+        icon: string | null;
+        banner: string | null;
+        isBotIn: boolean;
+        id: string;
+        name: string;
+    }[];
+    user: CurrentUser;
+};

package/dist/classes/sessions.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APISessions = void 0;
+// Data.
+class APISessions {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async checkSession({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/sessions'),
+        });
+    }
+    async postSession({ code, auth, addToServer }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp('/sessions', {
+                code,
+                add: addToServer || true,
+            }),
+        });
+    }
+    async deleteSession({ auth }) {
+        return await this.web.request({ method: 'DELETE', endpoint: this.web.qp('/sessions'), auth });
+    }
+}
+exports.APISessions = APISessions;

package/dist/classes/teams.d.ts

@@ -0,0 +1,88 @@
+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>>;
+    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>>;
+}
+export type TeamsFunctionsInput = {
+    'getAllUserTeams': {
+        auth: string;
+    };
+    'createTeam': {
+        auth: string;
+        teamName: string;
+    };
+    'joinOrLeaveTeam': {
+        auth: string;
+        teamOrCode: string;
+        action: 'join' | 'leave';
+    };
+    'createTeamInvite': {
+        auth: string;
+        teamId: string;
+        maxUses: number;
+        bitfieldToSet: string;
+        expiresAt: number;
+    };
+    'kickTeamMember': {
+        auth: string;
+        teamId: string;
+        userId: string;
+    };
+    'updateMemberPermissions': {
+        auth: string;
+        teamId: string;
+        userId: string;
+        bitfieldToSet: string;
+    };
+    'updateTeamName': {
+        auth: string;
+        teamId: string;
+        teamName: string;
+    };
+    'deleteTeam': {
+        auth: string;
+        teamId: string;
+    };
+};
+export type TeamsGetReturnTypes = {
+    'getAllUserTeamsRaw': Awaited<ReturnType<APITeams['getAllUserTeams']>>;
+    'getAllUserTeamsSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['getAllUserTeams']>>>;
+    'createTeamRaw': Awaited<ReturnType<APITeams['createTeam']>>;
+    'createTeamSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['createTeam']>>>;
+    'joinOrLeaveTeamRaw': Awaited<ReturnType<APITeams['joinOrLeaveTeam']>>;
+    'joinOrLeaveTeamSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['joinOrLeaveTeam']>>>;
+    'createTeamInviteRaw': Awaited<ReturnType<APITeams['createTeamInvite']>>;
+    'createTeamInviteSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['createTeamInvite']>>>;
+    'kickTeamMemberRaw': Awaited<ReturnType<APITeams['kickTeamMember']>>;
+    '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']>>>;
+    'deleteTeamRaw': Awaited<ReturnType<APITeams['deleteTeam']>>;
+    'deleteTeamSuccess': CancelOutWebResponses<Awaited<ReturnType<APITeams['deleteTeam']>>>;
+};
+export type TeamsGetType = {
+    managedTeam: Team & {
+        teamMembers: (Team['teamMembers'][number] & {
+            username: string | null;
+            kickUsername: string | null;
+        })[];
+    };
+    memberTeams: {
+        teamId: string;
+        teamName: string;
+        teamMembers: number;
+        teamLeaderName: string | null;
+    }[];
+};