@vencord/types 1.8.4 → 1.13.1

package/Vencord.d.ts

@@ -15,6 +15,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
+import "~plugins";
 export * as Api from "./api";
 export * as Components from "./components";
 export * as Plugins from "./plugins";
@@ -22,6 +23,7 @@ export * as Util from "./utils";
 export * as QuickCss from "./utils/quickCss";
 export * as Updater from "./utils/updater";
 export * as Webpack from "./webpack";
+export * as WebpackPatcher from "./webpack/patchWebpack";
 export { PlainSettings, Settings };
 import "./utils/quickCss";
 import "./webpack/patchWebpack";

package/api/Badges.d.ts

@@ -1,4 +1,3 @@
-import { User } from "discord-types/general";
 import { ComponentType, HTMLProps } from "react";
 export declare const enum BadgePosition {
     START = 0,
@@ -13,7 +12,9 @@ export interface ProfileBadge {
     image?: string;
     link?: string;
     /** Action to perform when you click the badge */
-    onClick?(event: React.MouseEvent<HTMLButtonElement, MouseEvent>, props: BadgeUserArgs): void;
+    onClick?(event: React.MouseEvent, props: ProfileBadge & BadgeUserArgs): void;
+    /** Action to perform when you right click the badge */
+    onContextMenu?(event: React.MouseEvent, props: BadgeUserArgs & BadgeUserArgs): void;
     /** Should the user display this badge? */
     shouldShow?(userInfo: BadgeUserArgs): boolean;
     /** Optional props (e.g. style) for the badge, ignored for component badges */
@@ -22,23 +23,27 @@ export interface ProfileBadge {
     position?: BadgePosition;
     /** The badge name to display, Discord uses this. Required for component badges */
     key?: string;
+    /**
+     * Allows dynamically returning multiple badges
+     */
+    getBadges?(userInfo: BadgeUserArgs): ProfileBadge[];
 }
 /**
  * Register a new badge with the Badges API
  * @param badge The badge to register
  */
-export declare function addBadge(badge: ProfileBadge): void;
+export declare function addProfileBadge(badge: ProfileBadge): void;
 /**
  * Unregister a badge from the Badges API
  * @param badge The badge to remove
  */
-export declare function removeBadge(badge: ProfileBadge): boolean;
+export declare function removeProfileBadge(badge: ProfileBadge): boolean;
 /**
  * Inject badges into the profile badges array.
  * You probably don't need to use this.
  */
 export declare function _getBadges(args: BadgeUserArgs): ProfileBadge[];
 export interface BadgeUserArgs {
-    user: User;
+    userId: string;
     guildId: string;
 }

package/api/ChatButtons.d.ts

@@ -1,6 +1,6 @@
 import "./ChatButton.css";
-import { Channel } from "discord-types/general";
-import { HTMLProps, MouseEventHandler, ReactNode } from "react";
+import { Channel } from "@vencord/discord-types";
+import { HTMLProps, JSX, MouseEventHandler, ReactNode } from "react";
 export interface ChatBarProps {
     channel: Channel;
     disabled: boolean;
@@ -58,17 +58,18 @@ export interface ChatBarProps {
         sedReplace: boolean;
     };
 }
-export type ChatBarButton = (props: ChatBarProps & {
+export type ChatBarButtonFactory = (props: ChatBarProps & {
     isMainChat: boolean;
 }) => JSX.Element | null;
 export declare function _injectButtons(buttons: ReactNode[], props: ChatBarProps): void;
-export declare const addChatBarButton: (id: string, button: ChatBarButton) => Map<string, ChatBarButton>;
+export declare const addChatBarButton: (id: string, button: ChatBarButtonFactory) => Map<string, ChatBarButtonFactory>;
 export declare const removeChatBarButton: (id: string) => boolean;
 export interface ChatBarButtonProps {
     children: ReactNode;
     tooltip: string;
     onClick: MouseEventHandler<HTMLButtonElement>;
     onContextMenu?: MouseEventHandler<HTMLButtonElement>;
-    buttonProps?: Omit<HTMLProps<HTMLButtonElement>, "size" | "onClick" | "onContextMenu">;
+    onAuxClick?: MouseEventHandler<HTMLButtonElement>;
+    buttonProps?: Omit<HTMLProps<HTMLButtonElement>, "size" | "onClick" | "onContextMenu" | "onAuxClick">;
 }
 export declare const ChatBarButton: import("react").FunctionComponent<ChatBarButtonProps>;

package/api/Commands/commandHelpers.d.ts

@@ -1,6 +1,5 @@
-import { Message } from "discord-types/general";
+import { CommandArgument, Message } from "@vencord/discord-types";
 import type { PartialDeep } from "type-fest";
-import { Argument } from "./types";
 export declare function generateId(): string;
 /**
  * Send a message as Clyde
@@ -16,5 +15,5 @@ export declare function sendBotMessage(channelId: string, message: PartialDeep<M
  * @param fallbackValue Fallback value in case this option wasn't passed
  * @returns Value
  */
-export declare function findOption<T>(args: Argument[], name: string): T & {} | undefined;
-export declare function findOption<T>(args: Argument[], name: string, fallbackValue: T): T & {};
+export declare function findOption<T>(args: CommandArgument[], name: string): T & {} | undefined;
+export declare function findOption<T>(args: CommandArgument[], name: string, fallbackValue: T): T & {};

package/api/Commands/index.d.ts

@@ -1,26 +1,27 @@
-import { Command, Option } from "./types";
+import { CommandOption } from "@vencord/discord-types";
+import { VencordCommand } from "./types";
 export * from "./commandHelpers";
 export * from "./types";
-export declare let BUILT_IN: Command[];
-export declare const commands: Record<string, Command>;
+export declare let BUILT_IN: VencordCommand[];
+export declare const commands: Record<string, VencordCommand>;
 /**
  * Optional message option named "message" you can use in commands.
  * Used in "tableflip" or "shrug"
  * @see {@link RequiredMessageOption}
  */
-export declare let OptionalMessageOption: Option;
+export declare let OptionalMessageOption: CommandOption;
 /**
  * Required message option named "message" you can use in commands.
  * Used in "me"
  * @see {@link OptionalMessageOption}
  */
-export declare let RequiredMessageOption: Option;
+export declare let RequiredMessageOption: CommandOption;
 export declare const _init: never;
 export declare const _handleCommand: never;
 /**
  * Prepare a Command Option for Discord by filling missing fields
  * @param opt
  */
-export declare function prepareOption<O extends Option | Command>(opt: O): O;
-export declare function registerCommand<C extends Command>(command: C, plugin: string): void;
+export declare function prepareOption<O extends CommandOption | VencordCommand>(opt: O): O;
+export declare function registerCommand<C extends VencordCommand>(command: C, plugin: string): void;
 export declare function unregisterCommand(name: string): boolean;

package/api/Commands/types.d.ts

@@ -1,74 +1,5 @@
-import { Channel, Guild } from "discord-types/general";
-import { Promisable } from "type-fest";
-export interface CommandContext {
-    channel: Channel;
-    guild?: Guild;
-}
-export declare const enum ApplicationCommandOptionType {
-    SUB_COMMAND = 1,
-    SUB_COMMAND_GROUP = 2,
-    STRING = 3,
-    INTEGER = 4,
-    BOOLEAN = 5,
-    USER = 6,
-    CHANNEL = 7,
-    ROLE = 8,
-    MENTIONABLE = 9,
-    NUMBER = 10,
-    ATTACHMENT = 11
-}
-export declare const enum ApplicationCommandInputType {
-    BUILT_IN = 0,
-    BUILT_IN_TEXT = 1,
-    BUILT_IN_INTEGRATION = 2,
-    BOT = 3,
-    PLACEHOLDER = 4
-}
-export interface Option {
-    name: string;
-    displayName?: string;
-    type: ApplicationCommandOptionType;
-    description: string;
-    displayDescription?: string;
-    required?: boolean;
-    options?: Option[];
-    choices?: Array<ChoicesOption>;
-}
-export interface ChoicesOption {
-    label: string;
-    value: string;
-    name: string;
-    displayName?: string;
-}
-export declare const enum ApplicationCommandType {
-    CHAT_INPUT = 1,
-    USER = 2,
-    MESSAGE = 3
-}
-export interface CommandReturnValue {
-    content: string;
-    /** TODO: implement */
-    cancel?: boolean;
-}
-export interface Argument {
-    type: ApplicationCommandOptionType;
-    name: string;
-    value: string;
-    focused: undefined;
-    options: Argument[];
-}
-export interface Command {
-    id?: string;
-    applicationId?: string;
-    type?: ApplicationCommandType;
-    inputType?: ApplicationCommandInputType;
-    plugin?: string;
+import { Command } from "@vencord/discord-types";
+export { ApplicationCommandInputType, ApplicationCommandOptionType, ApplicationCommandType } from "@vencord/discord-types/enums";
+export interface VencordCommand extends Command {
     isVencordCommand?: boolean;
-    name: string;
-    displayName?: string;
-    description: string;
-    displayDescription?: string;
-    options?: Option[];
-    predicate?(ctx: CommandContext): boolean;
-    execute(args: Argument[], ctx: CommandContext): Promisable<void | CommandReturnValue>;
 }

package/api/ContextMenu.d.ts

@@ -3,13 +3,13 @@ import type { ReactElement } from "react";
  * @param children The rendered context menu elements
  * @param args Any arguments passed into making the context menu, like the guild, channel, user or message for example
  */
-export type NavContextMenuPatchCallback = (children: Array<ReactElement | null>, ...args: Array<any>) => void;
+export type NavContextMenuPatchCallback = (children: Array<ReactElement<any> | null>, ...args: Array<any>) => void;
 /**
  * @param navId The navId of the context menu being patched
  * @param children The rendered context menu elements
  * @param args Any arguments passed into making the context menu, like the guild, channel, user or message for example
  */
-export type GlobalContextMenuPatchCallback = (navId: string, children: Array<ReactElement | null>, ...args: Array<any>) => void;
+export type GlobalContextMenuPatchCallback = (navId: string, children: Array<ReactElement<any> | null>, ...args: Array<any>) => void;
 export declare const navPatches: Map<string, Set<NavContextMenuPatchCallback>>;
 export declare const globalPatches: Set<GlobalContextMenuPatchCallback>;
 /**
@@ -40,12 +40,13 @@ export declare function removeGlobalContextMenuPatch(patch: GlobalContextMenuPat
  * A helper function for finding the children array of a group nested inside a context menu based on the id(s) of its children
  * @param id The id of the child. If an array is specified, all ids will be tried
  * @param children The context menu children
+ * @param matchSubstring Whether to check if the id is a substring of the child id
  */
-export declare function findGroupChildrenByChildId(id: string | string[], children: Array<ReactElement | null>): Array<ReactElement | null> | null;
+export declare function findGroupChildrenByChildId(id: string | string[], children: Array<ReactElement<any> | null | undefined>, matchSubstring?: boolean): Array<ReactElement<any> | null | undefined> | null;
 interface ContextMenuProps {
-    contextMenuApiArguments?: Array<any>;
+    contextMenuAPIArguments?: Array<any>;
     navId: string;
-    children: Array<ReactElement | null>;
+    children: Array<ReactElement<any> | null>;
     "aria-label": string;
     onSelect: (() => void) | undefined;
     onClose: (callback: (...args: Array<any>) => any) => void;

package/api/MemberListDecorators.d.ts

@@ -1,32 +1,20 @@
-/// <reference types="react" />
-import { Channel, User } from "discord-types/general/index.js";
+import { Channel, User } from "@vencord/discord-types";
+import { JSX } from "react";
 interface DecoratorProps {
-    activities: any[];
-    channel: Channel;
-    /**
-     * Only for DM members
-     */
-    channelName?: string;
-    /**
-     * Only for server members
-     */
-    currentUser?: User;
-    guildId?: string;
-    isMobile: boolean;
-    isOwner?: boolean;
-    isTyping: boolean;
-    selected: boolean;
-    status: string;
+    type: "guild" | "dm";
     user: User;
-    [key: string]: any;
+    /** only present when this is a DM list item */
+    channel: Channel;
+    /** only present when this is a guild list item */
+    isOwner: boolean;
 }
-export type Decorator = (props: DecoratorProps) => JSX.Element | null;
+export type MemberListDecoratorFactory = (props: DecoratorProps) => JSX.Element | null;
 type OnlyIn = "guilds" | "dms";
-export declare const decorators: Map<string, {
-    decorator: Decorator;
-    onlyIn?: OnlyIn | undefined;
+export declare const decoratorsFactories: Map<string, {
+    render: MemberListDecoratorFactory;
+    onlyIn?: OnlyIn;
 }>;
-export declare function addDecorator(identifier: string, decorator: Decorator, onlyIn?: OnlyIn): void;
-export declare function removeDecorator(identifier: string): void;
-export declare function __getDecorators(props: DecoratorProps): (JSX.Element | null)[];
+export declare function addMemberListDecorator(identifier: string, render: MemberListDecoratorFactory, onlyIn?: OnlyIn): void;
+export declare function removeMemberListDecorator(identifier: string): void;
+export declare function __getDecorators(props: DecoratorProps, type: "guild" | "dm"): JSX.Element;
 export {};

package/api/MessageAccessories.d.ts

@@ -1,10 +1,10 @@
-/// <reference types="react" />
-export type AccessoryCallback = (props: Record<string, any>) => JSX.Element | null | Array<JSX.Element | null>;
-export type Accessory = {
-    callback: AccessoryCallback;
+import { JSX, ReactNode } from "react";
+export type MessageAccessoryFactory = (props: Record<string, any>) => ReactNode;
+export type MessageAccessory = {
+    render: MessageAccessoryFactory;
     position?: number;
 };
-export declare const accessories: Map<String, Accessory>;
-export declare function addAccessory(identifier: string, callback: AccessoryCallback, position?: number): void;
-export declare function removeAccessory(identifier: string): void;
+export declare const accessories: Map<string, MessageAccessory>;
+export declare function addMessageAccessory(identifier: string, render: MessageAccessoryFactory, position?: number): void;
+export declare function removeMessageAccessory(identifier: string): void;
 export declare function _modifyAccessories(elements: JSX.Element[], props: Record<string, any>): JSX.Element[];

package/api/MessageDecorations.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="react" />
-import { Channel, Message } from "discord-types/general/index.js";
-interface DecorationProps {
+import { Channel, Message } from "@vencord/discord-types";
+import { JSX } from "react";
+export interface MessageDecorationProps {
     author: {
         /**
          * Will be username if the user has no nickname
@@ -26,9 +26,8 @@ interface DecorationProps {
     message: Message;
     [key: string]: any;
 }
-export type Decoration = (props: DecorationProps) => JSX.Element | null;
-export declare const decorations: Map<string, Decoration>;
-export declare function addDecoration(identifier: string, decoration: Decoration): void;
-export declare function removeDecoration(identifier: string): void;
-export declare function __addDecorationsToMessage(props: DecorationProps): (JSX.Element | null)[];
-export {};
+export type MessageDecorationFactory = (props: MessageDecorationProps) => JSX.Element | null;
+export declare const decorationsFactories: Map<string, MessageDecorationFactory>;
+export declare function addMessageDecoration(identifier: string, decoration: MessageDecorationFactory): void;
+export declare function removeMessageDecoration(identifier: string): void;
+export declare function __addDecorationsToMessage(props: MessageDecorationProps): JSX.Element;

package/api/MessageEvents.d.ts

@@ -1,5 +1,4 @@
-import { CustomEmoji } from "../webpack/common/types";
-import type { Channel, Message } from "discord-types/general";
+import type { Channel, CloudUpload, CustomEmoji, Message } from "@vencord/discord-types";
 import type { Promisable } from "type-fest";
 export interface MessageObject {
     content: string;
@@ -7,29 +6,6 @@ export interface MessageObject {
     invalidEmojis: any[];
     tts: boolean;
 }
-export interface Upload {
-    classification: string;
-    currentSize: number;
-    description: string | null;
-    filename: string;
-    id: string;
-    isImage: boolean;
-    isVideo: boolean;
-    item: {
-        file: File;
-        platform: number;
-    };
-    loaded: number;
-    mimeType: string;
-    preCompressionSize: number;
-    responseUrl: string;
-    sensitive: boolean;
-    showLargeMessageDialog: boolean;
-    spoiler: boolean;
-    status: "NOT_STARTED" | "STARTED" | "UPLOADING" | "ERROR" | "COMPLETED" | "CANCELLED";
-    uniqueId: string;
-    uploadedFilename: string;
-}
 export interface MessageReplyOptions {
     messageReference: Message["messageReference"];
     allowedMentions?: {
@@ -37,35 +13,34 @@ export interface MessageReplyOptions {
         repliedUser: boolean;
     };
 }
-export interface MessageExtra {
+export interface MessageOptions {
     stickers?: string[];
-    uploads?: Upload[];
+    uploads?: CloudUpload[];
     replyOptions: MessageReplyOptions;
     content: string;
     channel: Channel;
     type?: any;
     openWarningPopout: (props: any) => any;
 }
-export type SendListener = (channelId: string, messageObj: MessageObject, extra: MessageExtra) => Promisable<void | {
+export type MessageSendListener = (channelId: string, messageObj: MessageObject, options: MessageOptions) => Promisable<void | {
     cancel: boolean;
 }>;
-export type EditListener = (channelId: string, messageId: string, messageObj: MessageObject) => Promisable<void | {
+export type MessageEditListener = (channelId: string, messageId: string, messageObj: MessageObject) => Promisable<void | {
     cancel: boolean;
 }>;
-export declare function _handlePreSend(channelId: string, messageObj: MessageObject, extra: MessageExtra, replyOptions: MessageReplyOptions): Promise<boolean>;
+export declare function _handlePreSend(channelId: string, messageObj: MessageObject, options: MessageOptions, replyOptions: MessageReplyOptions): Promise<boolean>;
 export declare function _handlePreEdit(channelId: string, messageId: string, messageObj: MessageObject): Promise<boolean>;
 /**
  * Note: This event fires off before a message is sent, allowing you to edit the message.
  */
-export declare function addPreSendListener(listener: SendListener): SendListener;
+export declare function addMessagePreSendListener(listener: MessageSendListener): MessageSendListener;
 /**
  * Note: This event fires off before a message's edit is applied, allowing you to further edit the message.
  */
-export declare function addPreEditListener(listener: EditListener): EditListener;
-export declare function removePreSendListener(listener: SendListener): boolean;
-export declare function removePreEditListener(listener: EditListener): boolean;
-type ClickListener = (message: Message, channel: Channel, event: MouseEvent) => void;
+export declare function addMessagePreEditListener(listener: MessageEditListener): MessageEditListener;
+export declare function removeMessagePreSendListener(listener: MessageSendListener): boolean;
+export declare function removeMessagePreEditListener(listener: MessageEditListener): boolean;
+export type MessageClickListener = (message: Message, channel: Channel, event: MouseEvent) => void;
 export declare function _handleClick(message: Message, channel: Channel, event: MouseEvent): void;
-export declare function addClickListener(listener: ClickListener): ClickListener;
-export declare function removeClickListener(listener: ClickListener): boolean;
-export {};
+export declare function addMessageClickListener(listener: MessageClickListener): MessageClickListener;
+export declare function removeMessageClickListener(listener: MessageClickListener): boolean;

package/api/MessagePopover.d.ts

@@ -1,16 +1,16 @@
-import { Channel, Message } from "discord-types/general";
-import type { MouseEventHandler } from "react";
-export interface ButtonItem {
+import { Channel, Message } from "@vencord/discord-types";
+import type { ComponentType, MouseEventHandler } from "react";
+export interface MessagePopoverButtonItem {
     key?: string;
     label: string;
-    icon: React.ComponentType<any>;
+    icon: ComponentType<any>;
     message: Message;
     channel: Channel;
     onClick?: MouseEventHandler<HTMLButtonElement>;
     onContextMenu?: MouseEventHandler<HTMLButtonElement>;
 }
-export type getButtonItem = (message: Message) => ButtonItem | null;
-export declare const buttons: Map<string, getButtonItem>;
-export declare function addButton(identifier: string, item: getButtonItem): void;
-export declare function removeButton(identifier: string): void;
-export declare function _buildPopoverElements(msg: Message, makeButton: (item: ButtonItem) => React.ComponentType): import("react").ComponentType<{}>[];
+export type MessagePopoverButtonFactory = (message: Message) => MessagePopoverButtonItem | null;
+export declare const buttons: Map<string, MessagePopoverButtonFactory>;
+export declare function addMessagePopoverButton(identifier: string, item: MessagePopoverButtonFactory): void;
+export declare function removeMessagePopoverButton(identifier: string): void;
+export declare function _buildPopoverElements(Component: React.ComponentType<MessagePopoverButtonItem>, message: Message): import("react").JSX.Element;

package/api/MessageUpdater.d.ts

@@ -0,0 +1,8 @@
+import { Message } from "@vencord/discord-types";
+/**
+ * Update and re-render a message
+ * @param channelId The channel id of the message
+ * @param messageId The message id
+ * @param fields The fields of the message to change. Leave empty if you just want to re-render
+ */
+export declare function updateMessage(channelId: string, messageId: string, fields?: Partial<Message & Record<string, any>>): void;

package/api/Notices.d.ts

@@ -1,5 +1,6 @@
+import { ReactNode } from "react";
 export declare const noticesQueue: any[];
 export declare let currentNotice: any;
 export declare function popNotice(): void;
 export declare function nextNotice(): void;
-export declare function showNotice(message: string, buttonText: string, onOkClick: () => void): void;
+export declare function showNotice(message: ReactNode, buttonText: string, onOkClick: () => void): void;

package/api/Notifications/NotificationComponent.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="react" />
 import "./styles.css";
 import { NotificationData } from "./Notifications";
 declare const _default: import("react").FunctionComponent<NotificationData & {
-    className?: string | undefined;
+    className?: string;
 }>;
 export default _default;

package/api/Notifications/notificationLog.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { NotificationData } from "./Notifications";
 interface PersistentNotificationData extends Pick<NotificationData, "title" | "body" | "image" | "icon" | "color"> {
     timestamp: number;
@@ -10,6 +9,6 @@ export declare function useLogs(): readonly [PersistentNotificationData[], boole
 export declare function NotificationLog({ log, pending }: {
     log: PersistentNotificationData[];
     pending: boolean;
-}): JSX.Element;
+}): import("react").JSX.Element;
 export declare function openNotificationLogModal(): void;
 export {};

package/api/ServerList.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="react" />
+import { ComponentType } from "react";
 export declare const enum ServerListRenderPosition {
     Above = 0,
     In = 1
 }
-export declare function addServerListElement(position: ServerListRenderPosition, renderFunction: Function): void;
-export declare function removeServerListElement(position: ServerListRenderPosition, renderFunction: Function): void;
-export declare const renderAll: (position: ServerListRenderPosition) => JSX.Element[];
+export declare function addServerListElement(position: ServerListRenderPosition, renderFunction: ComponentType): void;
+export declare function removeServerListElement(position: ServerListRenderPosition, renderFunction: ComponentType): void;
+export declare const renderAll: (position: ServerListRenderPosition) => import("react").JSX.Element[];

package/api/Settings.d.ts

@@ -4,9 +4,10 @@ export interface Settings {
     autoUpdate: boolean;
     autoUpdateNotification: boolean;
     useQuickCss: boolean;
+    eagerPatches: boolean;
+    enabledThemes: string[];
     enableReactDevtools: boolean;
     themeLinks: string[];
-    enabledThemes: string[];
     frameless: boolean;
     transparent: boolean;
     winCtrlQ: boolean;
@@ -57,6 +58,7 @@ export declare const Settings: Settings;
  */
 export declare function useSettings(paths?: UseSettings<Settings>[]): Settings;
 export declare function migratePluginSettings(name: string, ...oldNames: string[]): void;
+export declare function migratePluginSetting(pluginName: string, oldSetting: string, newSetting: string): void;
 export declare function definePluginSettings<Def extends SettingsDefinition, Checks extends SettingsChecks<Def>, PrivateSettings extends object = {}>(def: Def, checks?: Checks): DefinedSettings<Def, Checks, PrivateSettings>;
 type UseSettings<T extends object> = ResolveUseSettings<T>[keyof T];
 type ResolveUseSettings<T extends object> = {

package/api/Styles.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="../src/globals" />
 import type { MapValue } from "type-fest/source/entry";
 export type Style = MapValue<typeof VencordStyles>;
 export declare const styleMap: Map<string, {

package/api/UserSettings.d.ts

@@ -0,0 +1,40 @@
+interface UserSettingDefinition<T> {
+    /**
+     * Get the setting value
+     */
+    getSetting(): T;
+    /**
+     * Update the setting value
+     * @param value The new value
+     */
+    updateSetting(value: T): Promise<void>;
+    /**
+     * Update the setting value
+     * @param value A callback that accepts the old value as the first argument, and returns the new value
+     */
+    updateSetting(value: (old: T) => T): Promise<void>;
+    /**
+     * Stateful React hook for this setting value
+     */
+    useSetting(): T;
+    userSettingsAPIGroup: string;
+    userSettingsAPIName: string;
+}
+export declare const UserSettings: Record<PropertyKey, UserSettingDefinition<any>> | undefined;
+/**
+ * Get the setting with the given setting group and name.
+ *
+ * @param group The setting group
+ * @param name The name of the setting
+ */
+export declare function getUserSetting<T = any>(group: string, name: string): UserSettingDefinition<T> | undefined;
+/**
+ * {@link getUserSettingDefinition}, lazy.
+ *
+ * Get the setting with the given setting group and name.
+ *
+ * @param group The setting group
+ * @param name The name of the setting
+ */
+export declare function getUserSettingLazy<T = any>(group: string, name: string): UserSettingDefinition<T> | undefined;
+export {};

package/api/index.d.ts

@@ -8,11 +8,13 @@ import * as $MessageAccessories from "./MessageAccessories";
 import * as $MessageDecorations from "./MessageDecorations";
 import * as $MessageEventsAPI from "./MessageEvents";
 import * as $MessagePopover from "./MessagePopover";
+import * as $MessageUpdater from "./MessageUpdater";
 import * as $Notices from "./Notices";
 import * as $Notifications from "./Notifications";
 import * as $ServerList from "./ServerList";
 import * as $Settings from "./Settings";
 import * as $Styles from "./Styles";
+import * as $UserSettings from "./UserSettings";
 /**
  * An API allowing you to listen to Message Clicks or run your own logic
  * before a message is sent
@@ -89,3 +91,11 @@ export declare const ContextMenu: typeof $ContextMenu;
  * An API allowing you to add buttons to the chat input
  */
 export declare const ChatButtons: typeof $ChatButtons;
+/**
+ * An API allowing you to update and re-render messages
+ */
+export declare const MessageUpdater: typeof $MessageUpdater;
+/**
+ * An API allowing you to get an user setting
+ */
+export declare const UserSettings: typeof $UserSettings;

package/components/CheckedTextInput.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 interface TextInputProps {
     /**
      * WARNING: Changing this between renders will have no effect!
@@ -19,5 +18,5 @@ interface TextInputProps {
  * A very simple wrapper around Discord's TextInput that validates input and shows
  * the user an error message and only calls your onChange when the input is valid
  */
-export declare function CheckedTextInput({ value: initialValue, onChange, validate }: TextInputProps): JSX.Element;
+export declare function CheckedTextInput({ value: initialValue, onChange, validate }: TextInputProps): import("react").JSX.Element;
 export {};

package/components/CodeBlock.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="react" />
 /**
  * Renders code in a Discord codeblock
  */
 export declare function CodeBlock(props: {
     content?: string;
     lang: string;
-}): JSX.Element;
+}): import("react").JSX.Element;