@crowbartools/firebot-types 5.67.0-alpha2 → 5.67.0-alpha21

package/backend/roles/firebot-roles-manager.d.ts

@@ -0,0 +1,7 @@
+import type { FirebotRole } from "../../types";
+declare class FirebotRolesManager {
+    private userIsInFirebotRole;
+    getAllFirebotRolesForViewer(userIdOrName: string): FirebotRole[];
+}
+declare const firebotRolesManager: FirebotRolesManager;
+export = firebotRolesManager;

package/backend/roles/role-helpers.d.ts

@@ -0,0 +1,28 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { FirebotRole } from "../../types";
+export interface FirebotViewerRoles {
+    twitchRoles: FirebotRole[];
+    firebotRoles: FirebotRole[];
+    customRoles: FirebotRole[];
+    teamRoles: FirebotRole[];
+}
+type Events = {
+    "viewer-role-updated": (userId: string, roleId: string, action: "added" | "removed") => void;
+};
+declare class RoleHelpers extends TypedEmitter<Events> {
+    constructor();
+    getAllRolesForViewer(userId: string): Promise<FirebotRole[]>;
+    getAllRolesForViewerNameSpaced(userId: string): Promise<FirebotViewerRoles>;
+    viewerHasRole(userId: string, expectedRoleId: string): Promise<boolean>;
+    viewerHasRoleByName(userId: string, expectedRoleName: string): Promise<boolean>;
+    /**
+    * Check if user has the given roles by their ids
+    */
+    viewerHasRoles(userId: string, expectedRoleIds: string[]): Promise<boolean>;
+    /**
+    * Check if user has the given roles by their names
+    */
+    viewerHasRolesByName(userId: string, expectedRoleNames: string[]): Promise<boolean>;
+}
+declare const roleHelpers: RoleHelpers;
+export default roleHelpers;

package/backend/roles/team-roles-manager.d.ts

@@ -0,0 +1,10 @@
+import type { FirebotRole } from "../../types";
+declare class TeamRolesManager {
+    private _streamerTeams;
+    constructor();
+    loadTeamRoles(): Promise<void>;
+    getTeamRoles(): Promise<FirebotRole[]>;
+    getAllTeamRolesForViewer(userIdOrName: string): Promise<FirebotRole[]>;
+}
+declare const teamRolesManager: TeamRolesManager;
+export = teamRolesManager;

package/backend/roles/twitch-roles-manager.d.ts

@@ -0,0 +1,31 @@
+import { TypedEmitter } from "tiny-typed-emitter";
+import type { BasicViewer } from "../../types";
+interface Subscriber {
+    id: string;
+    username: string;
+    displayName?: string;
+    subTier: string;
+}
+type Events = {
+    "viewer-role-updated": (userId: string, roleId: string, action: "added" | "removed") => void;
+};
+declare class TwitchRolesManager extends TypedEmitter<Events> {
+    private _vips;
+    private _moderators;
+    private _subscribers;
+    constructor();
+    setupListeners(): void;
+    loadVips(): Promise<void>;
+    getVips(): BasicViewer[];
+    addVipToVipList(viewer: BasicViewer): void;
+    removeVipFromVipList(userId: string): void;
+    loadModerators(): Promise<void>;
+    getModerators(): BasicViewer[];
+    addModeratorToModeratorsList(viewer: BasicViewer): void;
+    removeModeratorFromModeratorsList(userId: string): void;
+    loadSubscribers(): Promise<void>;
+    getSubscribers(): Subscriber[];
+    private getRoleForSubTier;
+}
+declare const twitchRolesManager: TwitchRolesManager;
+export = twitchRolesManager;

package/backend/secrets-manager.d.ts

@@ -0,0 +1,17 @@
+interface FirebotSecrets {
+    twitchClientId: string;
+    tipeeeStreamClientId: string;
+    tipeeeStreamClientSecret: string;
+    streamLabsClientId: string;
+    streamLabsClientSecret: string;
+    fontAwesome5KitId: string;
+}
+declare class SecretsManager {
+    private logger;
+    secrets: FirebotSecrets;
+    expectedKeys: (keyof FirebotSecrets)[];
+    constructor();
+    testSecrets(): boolean;
+}
+declare const secretsManager: SecretsManager;
+export { secretsManager as SecretsManager };

package/backend/setups/setup-manager.d.ts

@@ -0,0 +1,20 @@
+import type { FirebotSetup } from "../../types";
+export interface LoadSetupResult {
+    success: boolean;
+    setup?: FirebotSetup;
+    error?: string;
+}
+declare class SetupManager {
+    private logger;
+    constructor();
+    setupListeners(): void;
+    private loadSetup;
+    private createSetup;
+    private findAndReplaceCurrency;
+    private replaceQuestionAnswers;
+    private replaceCurrency;
+    private importSetup;
+    private removeSetupComponents;
+}
+declare const manager: SetupManager;
+export { manager as SetupManager };

package/backend/sort-tags/sort-tag-manager.d.ts

@@ -0,0 +1,17 @@
+import type { SortTag } from "../../types";
+interface SortTagCache {
+    [context: string]: SortTag[];
+}
+declare class SortTagManager {
+    private logger;
+    sortTags: SortTagCache;
+    constructor();
+    getSortTagsDb(): import("node-json-db/dist/JsonDB").JsonDB;
+    loadSortTags(): void;
+    private getLegacyEventAndCommandTags;
+    saveSortTagsForContext(context: string, sortTags: SortTag[]): void;
+    getSortTagsForContext(context: string): SortTag[];
+    private saveAllSortTags;
+}
+declare const sortTagManager: SortTagManager;
+export { sortTagManager as SortTagManager };

package/backend/streaming-platforms/twitch/ad-manager.d.ts

@@ -0,0 +1,18 @@
+declare class AdManager {
+    private logger;
+    private _adCheckIntervalId;
+    private _nextAdBreak;
+    private _isAdCheckRunning;
+    private _upcomingEventTriggered;
+    private _isAdRunning;
+    constructor();
+    get secondsUntilNextAdBreak(): number;
+    get isAdBreakRunning(): boolean;
+    runAdCheck(): Promise<void>;
+    triggerAdBreakStart(duration: number, endsAt: Date): void;
+    triggerAdBreakComplete(): void;
+    startAdCheck(): Promise<void>;
+    stopAdCheck(): void;
+}
+declare const adManager: AdManager;
+export = adManager;

package/backend/streaming-platforms/twitch/api/eventsub/custom-subscriptions/power-up-redemption-add-subscription.d.ts

@@ -0,0 +1,30 @@
+import type { HelixEventSubSubscription } from "@twurple/api";
+import { EventSubSubscription, EventSubBase } from "@twurple/eventsub-base";
+type EventData = {
+    id: string;
+    broadcaster_user_id: string;
+    broadcaster_user_login: string;
+    broadcaster_user_name: string;
+    user_id: string;
+    user_login: string;
+    user_name: string;
+    user_input: string;
+    status: string;
+    custom_power_up: {
+        id: string;
+        title: string;
+        bits_cost: number;
+        prompt: string;
+    };
+    redeemed_at: string;
+};
+export declare class EventSubPowerUpRedemptionAddSubscription extends EventSubSubscription<EventData> {
+    private readonly _broadcasterId;
+    readonly _cliName = "power-up-redemption-add";
+    constructor(handler: (data: EventData) => void, client: EventSubBase, _broadcasterId: string);
+    get id(): string;
+    get authUserId(): string | null;
+    protected transformData(data: EventData): EventData;
+    protected _subscribe(): Promise<HelixEventSubSubscription>;
+}
+export {};

package/backend/streaming-platforms/twitch/api/eventsub/eventsub-chat-helpers.d.ts

@@ -0,0 +1,69 @@
+import type { HelixChatBadgeSet, HelixCheermoteList, HelixEmoteScale } from "@twurple/api";
+import { type EventSubAutoModMessageHoldV2Event, type EventSubChannelChatNotificationEvent, type EventSubUserWhisperMessageEvent, EventSubChannelChatMessageEvent } from "@twurple/eventsub-base";
+import type { FirebotChatMessage } from "../../../../../types/chat";
+import { ThirdPartyEmote } from "../../../../chat/third-party/third-party-emote-provider";
+export interface ChatBadge {
+    title: string;
+    url: string;
+}
+interface HelixEmoteBase {
+    id: string;
+    name: string;
+    getStaticImageUrl(scale?: HelixEmoteScale): string;
+    getAnimatedImageUrl(scale?: HelixEmoteScale): string;
+}
+declare class TwitchEventSubChatHelpers {
+    private logger;
+    private readonly CHAT_ACTION_REGEX;
+    private readonly URL_REGEX;
+    readonly HIGHLIGHT_MESSAGE_REWARD_ID = "highlight-message";
+    private _badgeCache;
+    private _colorCache;
+    private _getAllTwitchEmotes;
+    private _twitchEmotes;
+    private _thirdPartyEmotes;
+    private _thirdPartyEmoteProviders;
+    private _twitchCheermotes;
+    private _profilePicUrlCache;
+    constructor();
+    get badges(): HelixChatBadgeSet[];
+    get twitchEmotes(): {
+        streamer: HelixEmoteBase[];
+        bot: HelixEmoteBase[];
+    };
+    get thirdPartyEmotes(): ThirdPartyEmote[];
+    get twitchCheermotes(): HelixCheermoteList;
+    cacheBadges(): Promise<void>;
+    cacheTwitchEmotes(): Promise<void>;
+    cacheThirdPartyEmotes(): Promise<void>;
+    cacheCheermotes(): Promise<void>;
+    cacheChatAssets(): Promise<void>;
+    private _mapCachedEmotesForFrontend;
+    private getEmoteUrl;
+    private accountTaggedInText;
+    private parseMessageParts;
+    private parseEmote;
+    private parseEventSubEmote;
+    private parseCheermote;
+    private parseEventSubCheermote;
+    private parseFirebotCheermote;
+    private parseEventSubMention;
+    private parseChatBadges;
+    private updateAccountAvatar;
+    getUserProfilePicUrl(userId: string): Promise<string>;
+    setUserProfilePicUrl(userId: string, url: string, updateAccountAvatars?: boolean): void;
+    cacheUserColor(userId: string, color?: string | null): string;
+    /**
+     * Parses out any control characters from a chat message (like ACTION when /me is used)
+     * @param rawText Raw message text
+     * @returns Chat message text, stripped of control characters
+     */
+    private getChatMessage;
+    private buildBaseChatMessage;
+    buildChatMessageFromChatEvent(event: EventSubChannelChatMessageEvent | EventSubChannelChatNotificationEvent): Promise<FirebotChatMessage>;
+    buildFirebotChatMessageFromWhisper(message: EventSubUserWhisperMessageEvent): Promise<FirebotChatMessage>;
+    buildChatMessageFromAutoModEvent(event: EventSubAutoModMessageHoldV2Event): Promise<FirebotChatMessage>;
+    enrichMessageWithRanksAndRoles(firebotChatMessage: FirebotChatMessage): Promise<void>;
+}
+declare const chatHelpers: TwitchEventSubChatHelpers;
+export { chatHelpers as TwitchEventSubChatHelpers };

package/backend/streaming-platforms/twitch/api/eventsub/eventsub-client.d.ts

@@ -0,0 +1,11 @@
+declare class TwitchEventSubClient {
+    private logger;
+    private _eventSubListener;
+    private _subscriptions;
+    private createSubscriptions;
+    createClient(): void;
+    removeSubscriptions(): void;
+    disconnectEventSub(): void;
+}
+declare const client: TwitchEventSubClient;
+export { client as TwitchEventSubClient };

package/backend/streaming-platforms/twitch/api/eventsub/eventsub-helpers.d.ts

@@ -0,0 +1,7 @@
+import type { EventSubChannelRewardEvent, EventSubChannelSharedChatSessionParticipant } from "@twurple/eventsub-base";
+import type { SharedChatParticipant } from "../../../../../types";
+import type { CustomReward } from "../resource/channel-rewards";
+import { CustomPowerUp } from "../resource/power-ups";
+export declare function mapEventSubRewardToTwitchData(event: EventSubChannelRewardEvent): CustomReward;
+export declare function getChannelRewardOrPowerUpImageUrl(rewardOrPowerUp: CustomReward | CustomPowerUp): string;
+export declare function mapSharedChatParticipants(participants: EventSubChannelSharedChatSessionParticipant[]): Promise<SharedChatParticipant[]>;

package/backend/streaming-platforms/twitch/api/index.d.ts

@@ -0,0 +1,86 @@
+import { ApiClient } from "@twurple/api";
+import type { AuthProvider } from "@twurple/auth";
+import type { FirebotAccount } from "../../../../types/accounts";
+import { TwitchAuthApi } from "./resource/auth";
+import { TwitchBitsApi } from "./resource/bits";
+import { TwitchCategoriesApi } from "./resource/categories";
+import { TwitchChannelRewardsApi } from "./resource/channel-rewards";
+import { TwitchChannelsApi } from "./resource/channels";
+import { TwitchCharityApi } from "./resource/charity";
+import { TwitchChatApi } from "./resource/chat";
+import { TwitchClipsApi } from "./resource/clips";
+import { TwitchGoalsApi } from "./resource/goals";
+import { TwitchHypeTrainApi } from "./resource/hypetrain";
+import { TwitchModerationApi } from "./resource/moderation";
+import { TwitchPollsApi } from "./resource/polls";
+import { TwitchPowerUpsApi } from "./resource/power-ups";
+import { TwitchPredictionsApi } from "./resource/predictions";
+import { TwitchStreamsApi } from "./resource/streams";
+import { TwitchSubscriptionsApi } from "./resource/subscriptions";
+import { TwitchTeamsApi } from "./resource/teams";
+import { TwitchUsersApi } from "./resource/users";
+import { TwitchVideosApi } from "./resource/videos";
+import { TwitchWhispersApi } from "./resource/whispers";
+declare class TwitchApi {
+    private _streamerClient;
+    private _botClient;
+    constructor();
+    private refreshAccountData;
+    refreshAccounts(): Promise<void>;
+    setupApiClients(streamerProvider: AuthProvider, botProvider: AuthProvider): void;
+    /**
+     * @deprecated Use the {@linkcode streamerClient} and {@linkcode botClient} properties going forward
+     */
+    getClient(): ApiClient;
+    get streamerClient(): ApiClient;
+    get botClient(): ApiClient;
+    get moderationClient(): ApiClient;
+    get moderatorId(): string;
+    get accounts(): {
+        streamer: FirebotAccount;
+        bot: FirebotAccount;
+    };
+    get logger(): import("winston").Logger;
+    private _auth;
+    get auth(): TwitchAuthApi;
+    private _bits;
+    get bits(): TwitchBitsApi;
+    private _powerUps;
+    get powerUps(): TwitchPowerUpsApi;
+    private _categories;
+    get categories(): TwitchCategoriesApi;
+    private _channelRewards;
+    get channelRewards(): TwitchChannelRewardsApi;
+    private _channels;
+    get channels(): TwitchChannelsApi;
+    private _charity;
+    get charity(): TwitchCharityApi;
+    private _chat;
+    get chat(): TwitchChatApi;
+    private _clips;
+    get clips(): TwitchClipsApi;
+    private _goals;
+    get goals(): TwitchGoalsApi;
+    private _hypeTrain;
+    get hypeTrain(): TwitchHypeTrainApi;
+    private _moderation;
+    get moderation(): TwitchModerationApi;
+    private _polls;
+    get polls(): TwitchPollsApi;
+    private _preditions;
+    get predictions(): TwitchPredictionsApi;
+    private _streams;
+    get streams(): TwitchStreamsApi;
+    private _subscriptions;
+    get subscriptions(): TwitchSubscriptionsApi;
+    private _teams;
+    get teams(): TwitchTeamsApi;
+    private _users;
+    get users(): TwitchUsersApi;
+    private _videos;
+    get videos(): TwitchVideosApi;
+    private _whispers;
+    get whispers(): TwitchWhispersApi;
+}
+declare const twitchApi: TwitchApi;
+export { twitchApi as TwitchApi };

package/backend/streaming-platforms/twitch/api/resource/api-resource-base.d.ts

@@ -0,0 +1,17 @@
+import { ApiClient } from "@twurple/api";
+import { ListenerSignature, TypedEmitter } from "tiny-typed-emitter";
+import type { TwitchApi } from "../";
+export declare abstract class ApiResourceBase<T extends ListenerSignature<T> = unknown> extends TypedEmitter<T> {
+    private _apiBase;
+    constructor(apiBase: typeof TwitchApi);
+    protected get streamerClient(): ApiClient;
+    protected get botClient(): ApiClient;
+    protected get moderationClient(): ApiClient;
+    protected get moderatorId(): string;
+    protected get logger(): import("winston").Logger;
+    protected get accounts(): {
+        streamer: import("../../../../../types").FirebotAccount;
+        bot: import("../../../../../types").FirebotAccount;
+    };
+    protected get usersApi(): import("./users").TwitchUsersApi;
+}

package/backend/streaming-platforms/twitch/api/resource/auth.d.ts

@@ -0,0 +1,6 @@
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+export declare class TwitchAuthApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    isTokenValid(type: "streamer" | "bot"): Promise<boolean>;
+}

package/backend/streaming-platforms/twitch/api/resource/bits.d.ts

@@ -0,0 +1,9 @@
+import { HelixBitsLeaderboardEntry, HelixBitsLeaderboardPeriod, HelixCheermoteList } from "@twurple/api";
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export declare class TwitchBitsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    getChannelBitsLeaderboard(count?: number, period?: HelixBitsLeaderboardPeriod, startDate?: Date, userId?: string): Promise<HelixBitsLeaderboardEntry[]>;
+    getChannelBitsTopCheerers(count?: number, period?: HelixBitsLeaderboardPeriod, startDate?: Date): Promise<string[]>;
+    getChannelCheermotes(): Promise<HelixCheermoteList>;
+}

package/backend/streaming-platforms/twitch/api/resource/categories.d.ts

@@ -0,0 +1,19 @@
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+/**
+ * Defines a Twitch category
+ */
+export interface TwitchCategory {
+    /** The Twitch ID of the category */
+    id: string;
+    /** The name of the category */
+    name: string;
+    /** The box art or cover image URL of the category */
+    boxArtUrl: string;
+}
+export declare class TwitchCategoriesApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    private mapTwitchCategory;
+    getCategoryById(categoryId: string, size?: string): Promise<TwitchCategory>;
+    searchCategories(categoryName: string): Promise<TwitchCategory[]>;
+}

package/backend/streaming-platforms/twitch/api/resource/channel-rewards.d.ts

@@ -0,0 +1,74 @@
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export interface ImageSet {
+    url1x: string;
+    url2x: string;
+    url4x: string;
+}
+export interface CustomReward {
+    broadcasterId: string;
+    broadcasterLogin: string;
+    broadcasterName: string;
+    id: string;
+    title: string;
+    prompt: string;
+    cost: number;
+    image?: ImageSet;
+    defaultImage: ImageSet;
+    backgroundColor: string;
+    isEnabled: boolean;
+    isUserInputRequired: boolean;
+    maxPerStreamSetting: {
+        isEnabled: boolean;
+        maxPerStream: number;
+    };
+    maxPerUserPerStreamSetting: {
+        isEnabled: boolean;
+        maxPerUserPerStream: number;
+    };
+    globalCooldownSetting: {
+        isEnabled: boolean;
+        globalCooldownSeconds: number;
+    };
+    isPaused: boolean;
+    isInStock: boolean;
+    shouldRedemptionsSkipRequestQueue: boolean;
+    redemptionsRedeemedCurrentStream?: number;
+    cooldownExpiresAt?: Date;
+}
+export interface RewardRedemption {
+    id: string;
+    rewardId: string;
+    redemptionDate: Date;
+    userId: string;
+    userName: string;
+    userDisplayName: string;
+    rewardMessage?: string;
+}
+export interface RewardRedemptionsApprovalRequest {
+    rewardId: string;
+    redemptionIds?: string[];
+    approve?: boolean;
+}
+export declare class TwitchChannelRewardsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    private mapCustomRewardToCreateRewardPayload;
+    private mapCustomRewardToUpdateRewardPayload;
+    private mapCustomRewardResponse;
+    private mapCustomRewardRedemptionResponse;
+    /**
+     * Get an array of custom channel rewards
+     * @param {boolean} onlyManageable - Only get rewards manageable by Firebot
+     */
+    getCustomChannelRewards(onlyManageable?: boolean): Promise<CustomReward[]>;
+    getCustomChannelReward(rewardId: string): Promise<CustomReward>;
+    getManageableCustomChannelRewards(): Promise<CustomReward[]>;
+    getUnmanageableCustomChannelRewards(): Promise<CustomReward[]>;
+    getTotalChannelRewardCount(): Promise<number>;
+    createCustomChannelReward(reward: CustomReward): Promise<CustomReward>;
+    updateCustomChannelReward(reward: CustomReward): Promise<boolean>;
+    deleteCustomChannelReward(rewardId: string): Promise<boolean>;
+    getOpenChannelRewardRedemptions(): Promise<Record<string, RewardRedemption[]>>;
+    approveOrRejectChannelRewardRedemption(request: RewardRedemptionsApprovalRequest): Promise<boolean>;
+    approveOrRejectAllRedemptionsForChannelRewards(rewardIds: string[], approve?: boolean): Promise<boolean>;
+}

package/backend/streaming-platforms/twitch/api/resource/channels.d.ts

@@ -0,0 +1,64 @@
+import { HelixAdSchedule, HelixChannel, HelixChannelUpdate, HelixUserRelation, HelixChannelFollower } from "@twurple/api";
+import { ApiResourceBase } from './api-resource-base';
+import type { TwitchApi } from "../";
+export declare class TwitchChannelsApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    /**
+     * Get channel info (game, title, etc) for the given broadcaster user id
+     *
+     * @param broadcasterId The id of the broadcaster to get channel info for. Defaults to Streamer channel if left blank.
+     */
+    getChannelInformation(broadcasterId?: string): Promise<HelixChannel>;
+    /**
+     * Check whether a streamer is currently live.
+     *
+     * @param userId
+     */
+    getOnlineStatus(userId: string): Promise<boolean>;
+    /**
+     * Update the information of a Twitch channel.
+     *
+     * @param data
+     */
+    updateChannelInformation(data: HelixChannelUpdate): Promise<void>;
+    /**
+     * Get channel info (game, title, etc) for the given username
+     *
+     * @param username The id of the broadcaster to get channel info for.
+     */
+    getChannelInformationByUsername(username: string): Promise<HelixChannel>;
+    /**
+     * Retrieves the current ad schedule for the streamer's channel.
+     */
+    getAdSchedule(): Promise<HelixAdSchedule>;
+    /**
+     * Trigger a Twitch ad break. Default length 30 seconds.
+     *
+     * @param adLength How long the ad should run.
+     */
+    triggerAdBreak(adLength?: number): Promise<boolean>;
+    /**
+     * Snoozes the next scheduled mid-roll ad break by 5 minutes.
+     */
+    snoozeAdBreak(): Promise<boolean>;
+    /**
+     * Starts a raid
+     *
+     * @param targetUserId The Twitch user ID whose channel to raid
+     */
+    raidChannel(targetUserId: string): Promise<boolean>;
+    /**
+     * Cancels a raid
+     */
+    cancelRaid(): Promise<boolean>;
+    /**
+     * Gets all the VIPs in the streamer's channel
+     */
+    getVips(): Promise<HelixUserRelation[]>;
+    /**
+     * Gets an optionally specified amount of followers of the streamer's channel.
+     *
+     * @param amount The amount of followers that need to be retrieved. When omitted, retrieves all followers.
+     */
+    getFollowers(amount?: number): Promise<HelixChannelFollower[]>;
+}

package/backend/streaming-platforms/twitch/api/resource/charity.d.ts

@@ -0,0 +1,7 @@
+import { ApiResourceBase } from "./api-resource-base";
+import type { TwitchApi } from "../";
+export declare class TwitchCharityApi extends ApiResourceBase {
+    constructor(apiBase: typeof TwitchApi);
+    getCurrentCharityFundraiserTotal(): Promise<number>;
+    getCurrentCharityFundraiserGoal(): Promise<number>;
+}