@plexcord/types 1.13.2

package/Plexcord.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * Plexcord, a modification for Discord's desktop app
+ * Copyright (c) 2022 Vendicated and contributors
+ * Copyright (c) 2025 MutanPlex
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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";
+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";
+import { PlainSettings, Settings } from "./api/Settings";

package/PlexcordNative.d.ts

@@ -0,0 +1,56 @@
+import type { Settings } from "./api/Settings";
+import { CspRequestResult } from "./main/csp/manager";
+import type { UserThemeHeader } from "./main/themes";
+import { IpcEvents } from "./shared/IpcEvents";
+import { IpcRes } from "./utils/types";
+export declare function sendSync<T = any>(event: IpcEvents, ...args: any[]): T;
+declare const _default: {
+    themes: {
+        uploadTheme: (fileName: string, fileData: string) => Promise<void>;
+        deleteTheme: (fileName: string) => Promise<void>;
+        getThemesDir: () => Promise<string>;
+        getThemesList: () => Promise<UserThemeHeader[]>;
+        getThemeData: (fileName: string) => Promise<string | undefined>;
+        getSystemValues: () => Promise<Record<string, string>>;
+        openFolder: () => Promise<void>;
+    };
+    updater: {
+        getUpdates: () => Promise<IpcRes<Record<"message" | "hash" | "author", string>[]>>;
+        update: () => Promise<IpcRes<boolean>>;
+        rebuild: () => Promise<IpcRes<boolean>>;
+        getRepo: () => Promise<IpcRes<string>>;
+    };
+    settings: {
+        get: () => Settings;
+        set: (settings: Settings, pathToNotify?: string) => Promise<void>;
+        getSettingsDir: () => Promise<string>;
+        openFolder: () => Promise<void>;
+    };
+    quickCss: {
+        get: () => Promise<string>;
+        set: (css: string) => Promise<void>;
+        addChangeListener(cb: (newCss: string) => void): void;
+        addThemeChangeListener(cb: () => void): void;
+        openFile: () => Promise<void>;
+        openEditor: () => Promise<void>;
+    };
+    native: {
+        getVersions: () => Partial<NodeJS.ProcessVersions>;
+        openExternal: (url: string) => Promise<void>;
+    };
+    i18n: {
+        updateMainLocale: (locale?: string) => Promise<boolean>;
+    };
+    csp: {
+        /**
+         * Note: Only supports full explicit matches, not wildcards.
+         *
+         * If `*.example.com` is allowed, `isDomainAllowed("https://sub.example.com")` will return false.
+         */
+        isDomainAllowed: (url: string, directives: string[]) => Promise<boolean>;
+        removeOverride: (url: string) => Promise<boolean>;
+        requestAddOverride: (url: string, directives: string[], callerName: string) => Promise<CspRequestResult>;
+    };
+    pluginHelpers: Record<string, Record<string, (...args: any[]) => Promise<any>>>;
+};
+export default _default;

package/README.md

@@ -0,0 +1,11 @@
+# Plexcord Types
+
+Typings for Plexcord's api, published to npm
+
+```sh
+npm i @plexcord/types
+
+yarn add @plexcord/types
+
+pnpm add @plexcord/types
+```

package/api/AudioPlayer.d.ts

@@ -0,0 +1,151 @@
+export type AudioProcessor = (data: PreprocessAudioData) => void;
+export type AudioCallback = (() => void);
+export type AudioErrorHandler = ((error: Error) => void);
+export declare const audioProcessorFunctions: Record<string, AudioProcessor>;
+export declare enum AudioType {
+    /** An external URL that follows the Content Security Policy. */
+    URL = "url",
+    /** A base64-encoded data URI. */
+    DATA = "data-uri",
+    /** A Blob URI. */
+    BLOB = "blob",
+    /** A file path. */
+    PATH = "file-path",
+    /** An internal Discord audio filename (e.g. "discodo"). */
+    DISCORD = "discord",
+    /** Any other unrecognized audio type. */
+    OTHER = "other"
+}
+export interface PreprocessAudioData {
+    /** The original audio string passed to the player. */
+    audio: string;
+    /** The read-only type of audio of the original audio string. */
+    readonly type: AudioType;
+    /** The volume of the original audio between 0 and 100. */
+    volume: number;
+    /** The playback speed of the original audio between 0.0625 and 16. */
+    speed: number;
+}
+export interface AudioPlayerInternal {
+    preprocessDataOriginal: PreprocessAudioData;
+    preprocessDataPrevious: PreprocessAudioData | null;
+    preprocessDataCurrent: PreprocessAudioData;
+    audio: string;
+    _audio: null | Promise<HTMLAudioElement>;
+    _volume: number;
+    _speed: number;
+    outputChannel: string;
+    type: AudioType;
+    preload: boolean;
+    persistent: boolean;
+    onEnded?: AudioCallback;
+    onError?: AudioErrorHandler;
+    processAudio: () => void;
+    ensureAudio(): Promise<HTMLAudioElement>;
+    destroyAudio(): void;
+    loop(): void;
+    play(): void;
+    pause(): void;
+    stop(restart?: boolean): void;
+}
+export interface AudioPlayerInterface {
+    /** The internal Discord audio filename (e.g. "discodo"), a data URI, or an external URL that follows the CSP. */
+    audio: string;
+    /** The read-only type of audio determined during processing. */
+    readonly type: AudioType;
+    /** The duration of the audio in seconds, or null if not yet loaded. */
+    readonly duration: Promise<number> | null;
+    /** The current time of the audio in seconds, or null if not yet loaded. */
+    time: Promise<number> | null;
+    /** The paused state of the audio, or null if not yet loaded. */
+    paused: Promise<boolean> | null;
+    /** The muted state of the audio, or null if not yet loaded. */
+    muted: Promise<boolean> | null;
+    /** The volume of the audio between 0 and 100. */
+    volume: number;
+    /** The playback speed of the audio between 0.0625 and 16. */
+    speed: number;
+    /** Whether to load the audio immediately. If persistent is false, this will only apply until the first playback. */
+    preload: boolean;
+    /** Whether the audio element is persistent and not recreated for every playback. */
+    persistent: boolean;
+    /** Preloads the audio before playback. Automatically called when persistent is true. */
+    load(): void;
+    /** Sets the audio to loop until paused or stopped. */
+    loop(): void;
+    /** Plays the audio. */
+    play(): void;
+    /** Pauses the audio. */
+    pause(): void;
+    /** Stops the audio. */
+    stop(): void;
+    /** Plays the audio from the beginning. */
+    restart(): void;
+    /** Seeks to a specific time in seconds. */
+    seek(time: number): void;
+    /** Mutes the audio. */
+    mute(): void;
+    /** Unmutes the audio. */
+    unmute(): void;
+    /** Deletes the audio element. Necessary if persistent is true. */
+    delete(): void;
+}
+export interface AudioPlayerOptions {
+    /** The volume of the audio, between 0 and 100, defaulting to 100. */
+    volume?: number;
+    /** The playback speed of the audio, between 0.0625 and 16, defaulting to 1. */
+    speed?: number;
+    /** Whether to preload the audio as soon as the player is created. */
+    preload?: boolean;
+    /** Whether the audio element is persistent and not recreated for every playback. If persistent, you must call delete() to free the memory. Defaults to false. */
+    persistent?: boolean;
+    /** An optional callback that is called every time the audio finishes playing. */
+    onEnded?: AudioCallback;
+    /** An optional error handler that is called when an error occurs during audio playback. */
+    onError?: AudioErrorHandler;
+}
+/**
+ * Creates an audio player.
+ * @param audio The internal Discord audio filename (e.g. "discodo"), a data URI, or an external URL that follows the CSP.
+ * @param options Additional options for the audio player.
+ * @param options.volume The volume of the audio, between 0 and 100, defaulting to 100.
+ * @param options.speed The playback speed of the audio, between 0.0625 and 16, defaulting to 1.
+ * @param options.preload Whether to load the audio immediately. If persistent is false, this will only apply until the first playback.
+ * @param options.persistent Whether the audio element is persistent and not recreated for every playback. If persistent, you must call delete() to free the memory. Defaults to false.
+ * @param options.onEnded An optional callback that is called every time the audio finishes playing.
+ * @param options.onError An optional error handler that is passed an Error object when an error occurs during audio playback.
+ * @return The created audio player.
+ */
+export declare function createAudioPlayer(audio: string, options?: AudioPlayerOptions): AudioPlayerInterface;
+/**
+ * Plays an audio instantly and returns the player.
+ * @param audio The internal Discord audio filename (e.g. "discodo"), a data URI, or an external URL that follows the CSP.
+ * @param options Additional options for the audio player.
+ * @param options.volume The volume of the audio, between 0 and 100, defaulting to 100.
+ * @param options.speed The playback speed of the audio, between 0.0625 and 16, defaulting to 1.
+ * @param options.preload Whether to load the audio immediately. If persistent is false, this will only apply until the first playback.
+ * @param options.persistent Whether the audio element is persistent and not recreated for every playback. If persistent, you must call delete() to free the memory. Defaults to false.
+ * @param options.onEnded An optional callback that is called every time the audio finishes playing.
+ * @param options.onError An optional error handler that is passed an Error object when an error occurs during audio playback.
+ * @return The created audio player.
+ */
+export declare function playAudio(audio: string, options?: AudioPlayerOptions): AudioPlayerInterface;
+/**
+ * Identifies the type of audio based on its string.
+ * @param audio The audio string to identify.
+ * @returns The identified AudioType.
+ */
+export declare function identifyAudioType(audio: string): AudioType;
+/**
+ * Adds a function to process an audio before it is played.
+ * @param key A unique identifier for this audio processor. Plugin name is recommended.
+ * @param processor A function that takes an audio, volume (0-100), and type (AudioType), and returns the replacement audio and volume.
+ */
+export declare function addAudioProcessor(key: string, processor: AudioProcessor): void;
+/**
+ * Removes an audio processor by its key.
+ * @param key The unique identifier of the audio processor to remove.
+ */
+export declare function removeAudioProcessor(key: string): void;
+/** Returns an array of all internal Discord audio filenames. */
+export declare function defaultAudioNames(): string[];

package/api/Badges.d.ts

@@ -0,0 +1,49 @@
+import { ComponentType, HTMLProps } from "react";
+export declare const enum BadgePosition {
+    START = 0,
+    END = 1
+}
+export interface ProfileBadge {
+    /** The tooltip to show on hover. Required for image badges */
+    description?: string;
+    /** Custom component for the badge (tooltip not included) */
+    component?: ComponentType<ProfileBadge & BadgeUserArgs>;
+    /** The custom image to use */
+    image?: string;
+    link?: string;
+    /** Action to perform when you click the badge */
+    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 */
+    props?: HTMLProps<HTMLImageElement>;
+    /** Insert at start or end? */
+    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 addProfileBadge(badge: ProfileBadge): void;
+/**
+ * Unregister a badge from the Badges API
+ * @param badge The badge to remove
+ */
+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 {
+    userId: string;
+    guildId: string;
+}

package/api/ChatButtons.d.ts

@@ -0,0 +1,75 @@
+import "./ChatButton.css";
+import { Channel } from "@plexcord/discord-types";
+import { HTMLProps, JSX, MouseEventHandler, ReactNode } from "react";
+export interface ChatBarProps {
+    channel: Channel;
+    disabled: boolean;
+    isEmpty: boolean;
+    type: {
+        analyticsName: string;
+        attachments: boolean;
+        autocomplete: {
+            addReactionShortcut: boolean;
+            forceChatLayer: boolean;
+            reactions: boolean;
+        };
+        commands: {
+            enabled: boolean;
+        };
+        drafts: {
+            type: number;
+            commandType: number;
+            autoSave: boolean;
+        };
+        emojis: {
+            button: boolean;
+        };
+        gifs: {
+            button: boolean;
+            allowSending: boolean;
+        };
+        gifts: {
+            button: boolean;
+        };
+        permissions: {
+            requireSendMessages: boolean;
+        };
+        showThreadPromptOnReply: boolean;
+        stickers: {
+            button: boolean;
+            allowSending: boolean;
+            autoSuggest: boolean;
+        };
+        users: {
+            allowMentioning: boolean;
+        };
+        submit: {
+            button: boolean;
+            ignorePreference: boolean;
+            disableEnterToSubmit: boolean;
+            clearOnSubmit: boolean;
+            useDisabledStylesOnSubmit: boolean;
+        };
+        uploadLongMessages: boolean;
+        upsellLongMessages: {
+            iconOnly: boolean;
+        };
+        showCharacterCount: boolean;
+        sedReplace: boolean;
+    };
+}
+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: ChatBarButtonFactory) => Map<string, ChatBarButtonFactory>;
+export declare const removeChatBarButton: (id: string) => boolean;
+export interface ChatBarButtonProps {
+    children: ReactNode;
+    tooltip: string;
+    onClick: MouseEventHandler<HTMLButtonElement>;
+    onContextMenu?: MouseEventHandler<HTMLButtonElement>;
+    onAuxClick?: MouseEventHandler<HTMLButtonElement>;
+    buttonProps?: Omit<HTMLProps<HTMLButtonElement>, "size" | "onClick" | "onContextMenu" | "onAuxClick" | "ref">;
+}
+export declare const ChatBarButton: import("react").FunctionComponent<ChatBarButtonProps>;

package/api/Commands/commandHelpers.d.ts

@@ -0,0 +1,19 @@
+import { CommandArgument, Message } from "@plexcord/discord-types";
+import type { PartialDeep } from "type-fest";
+export declare function generateId(): string;
+/**
+ * Send a message as Clyde
+ * @param {string} channelId ID of channel to send message to
+ * @param {Message} message Message to send
+ * @returns {Message}
+ */
+export declare function sendBotMessage(channelId: string, message: PartialDeep<Message>): Message;
+/**
+ * Get the value of an option by name
+ * @param args Arguments array (first argument passed to execute)
+ * @param name Name of the argument
+ * @param fallbackValue Fallback value in case this option wasn't passed
+ * @returns Value
+ */
+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

@@ -0,0 +1,28 @@
+import { CommandOption } from "@plexcord/discord-types";
+import { PlexcordCommand } from "./types";
+export * from "./commandHelpers";
+export * from "./types";
+export declare let BUILT_IN: PlexcordCommand[];
+export declare const commands: Record<string, PlexcordCommand>;
+/**
+ * Optional message option named "message" you can use in commands.
+ * Used in "tableflip" or "shrug"
+ * @see {@link RequiredMessageOption}
+ */
+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: 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 CommandOption | PlexcordCommand>(opt: O): O;
+export declare function updateCommandTranslations(): void;
+export declare function registerCommand<C extends PlexcordCommand>(command: C, plugin: string): void;
+export declare function unregisterCommand(name: string): boolean;

package/api/Commands/types.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "@plexcord/discord-types";
+export { ApplicationCommandInputType, ApplicationCommandOptionType, ApplicationCommandType } from "@plexcord/discord-types/enums";
+export interface PlexcordCommand extends Command {
+    isPlexcordCommand?: boolean;
+}

package/api/ContextMenu.d.ts

@@ -0,0 +1,55 @@
+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<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<any> | null>, ...args: Array<any>) => void;
+export declare const navPatches: Map<string, Set<NavContextMenuPatchCallback>>;
+export declare const globalPatches: Set<GlobalContextMenuPatchCallback>;
+/**
+ * Add a context menu patch
+ * @param navId The navId(s) for the context menu(s) to patch
+ * @param patch The patch to be applied
+ */
+export declare function addContextMenuPatch(navId: string | Array<string>, patch: NavContextMenuPatchCallback): void;
+/**
+ * Add a global context menu patch that fires the patch for all context menus
+ * @param patch The patch to be applied
+ */
+export declare function addGlobalContextMenuPatch(patch: GlobalContextMenuPatchCallback): void;
+/**
+ * Remove a context menu patch
+ * @param navId The navId(s) for the context menu(s) to remove the patch
+ * @param patch The patch to be removed
+ * @returns Whether the patch was successfully removed from the context menu(s)
+ */
+export declare function removeContextMenuPatch<T extends string | Array<string>>(navId: T, patch: NavContextMenuPatchCallback): T extends string ? boolean : Array<boolean>;
+/**
+ * Remove a global context menu patch
+ * @param patch The patch to be removed
+ * @returns Whether the patch was successfully removed
+ */
+export declare function removeGlobalContextMenuPatch(patch: GlobalContextMenuPatchCallback): boolean;
+/**
+ * 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<any> | null | undefined>, matchSubstring?: boolean): Array<ReactElement<any> | null | undefined> | null;
+interface ContextMenuProps {
+    contextMenuAPIArguments?: Array<any>;
+    navId: string;
+    children: Array<ReactElement<any> | null>;
+    "aria-label": string;
+    onSelect: (() => void) | undefined;
+    onClose: (callback: (...args: Array<any>) => any) => void;
+}
+export declare function _usePatchContextMenu(props: ContextMenuProps): ContextMenuProps;
+export {};

package/api/DataStore/index.d.ts

@@ -0,0 +1,97 @@
+/*!
+ * idb-keyval v6.2.0
+ * Copyright 2016, Jake Archibald
+ * Copyright 2022, Vendicated
+ * Copyright (c) 2025 MutanPlex
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function promisifyRequest<T = undefined>(request: IDBRequest<T> | IDBTransaction): Promise<T>;
+export declare function createStore(dbName: string, storeName: string): UseStore;
+export type UseStore = <T>(txMode: IDBTransactionMode, callback: (store: IDBObjectStore) => T | PromiseLike<T>) => Promise<T>;
+/**
+ * Get a value by its key.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function get<T = any>(key: IDBValidKey, customStore?: UseStore): Promise<T | undefined>;
+/**
+ * Set a value with a key.
+ *
+ * @param key
+ * @param value
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function set(key: IDBValidKey, value: any, customStore?: UseStore): Promise<void>;
+/**
+ * Set multiple values at once. This is faster than calling set() multiple times.
+ * It's also atomic – if one of the pairs can't be added, none will be added.
+ *
+ * @param entries Array of entries, where each entry is an array of `[key, value]`.
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function setMany(entries: [IDBValidKey, any][], customStore?: UseStore): Promise<void>;
+/**
+ * Get multiple values by their keys
+ *
+ * @param keys
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function getMany<T = any>(keys: IDBValidKey[], customStore?: UseStore): Promise<T[]>;
+/**
+ * Update a value. This lets you see the old value and update it as an atomic operation.
+ *
+ * @param key
+ * @param updater A callback that takes the old value and returns a new value.
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function update<T = any>(key: IDBValidKey, updater: (oldValue: T | undefined) => T, customStore?: UseStore): Promise<void>;
+/**
+ * Delete a particular key from the store.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function del(key: IDBValidKey, customStore?: UseStore): Promise<void>;
+/**
+ * Delete multiple keys at once.
+ *
+ * @param keys List of keys to delete.
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function delMany(keys: IDBValidKey[], customStore?: UseStore): Promise<void>;
+/**
+ * Clear all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function clear(customStore?: UseStore): Promise<void>;
+/**
+ * Get all keys in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function keys<KeyType extends IDBValidKey>(customStore?: UseStore): Promise<KeyType[]>;
+/**
+ * Get all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function values<T = any>(customStore?: UseStore): Promise<T[]>;
+/**
+ * Get all entries in the store. Each entry is an array of `[key, value]`.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function entries<KeyType extends IDBValidKey, ValueType = any>(customStore?: UseStore): Promise<[KeyType, ValueType][]>;

package/api/LocaleLoader.d.ts

@@ -0,0 +1,49 @@
+import { LocaleData } from "./i18n";
+export declare class LocaleLoader {
+    private static loadedCoreLocales;
+    private static loadedPluginLocales;
+    static loadCoreLocales(): Promise<void>;
+    /**
+     * Register a plugin's locale loader
+     * @param pluginName The plugin name
+     * @param locale The locale code
+     * @param loader Function that returns a promise with locale data
+     */
+    static registerPluginLocale(pluginName: string, locale: string, loader: () => Promise<{
+        default: LocaleData;
+    }>): void;
+    /**
+     * Load a specific plugin locale
+     * @param pluginName The plugin name
+     * @param locale The locale code
+     */
+    static loadPluginLocale(pluginName: string, locale: string): Promise<boolean>;
+    /**
+     * Load all locales for a specific plugin
+     * @param pluginName The plugin name
+     */
+    static loadPluginLocales(pluginName: string): Promise<void>;
+    /**
+     * Unregister all locales for a plugin
+     * @param pluginName The plugin name
+     */
+    static unregisterPlugin(pluginName: string): void;
+    static getRegisteredPlugins(): string[];
+    /**
+     * Get available locales for a plugin
+     * @param pluginName The plugin name
+     */
+    static getPluginLocales(pluginName: string): string[];
+    /**
+     * Check if a plugin has a specific locale
+     * @param pluginName The plugin name
+     * @param locale The locale code
+     */
+    static hasPluginLocale(pluginName: string, locale: string): boolean;
+    static loadCurrentLocales(): Promise<void>;
+    static initialize(): Promise<void>;
+}
+export declare function definePluginLocales(pluginName: string, locales: Record<string, () => Promise<{
+    default: LocaleData;
+}>>): void;
+export default LocaleLoader;

package/api/MemberListDecorators.d.ts

@@ -0,0 +1,20 @@
+import { Channel, User } from "@plexcord/discord-types";
+import { JSX } from "react";
+export type DecoratorProps = {
+    type: "guild" | "dm";
+    user: User;
+    /** only present when this is a DM list item */
+    channel: Channel;
+    /** only present when this is a guild list item */
+    isOwner: boolean;
+};
+export type MemberListDecoratorFactory = (props: DecoratorProps) => JSX.Element | null;
+type OnlyIn = "guilds" | "dms";
+export declare const decoratorsFactories: Map<string, {
+    render: MemberListDecoratorFactory;
+    onlyIn?: OnlyIn;
+}>;
+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

@@ -0,0 +1,10 @@
+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, 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[];