Global

Logs a deprecation warning for the decorated class if an instance is created

Logs a deprecation warning for the decorated class method if it is called within the current process

Property decorator that will automatically assign the Logger singleton instance to the decorated class property

Example:

class Foo {
    @logger private readonly logger: Logger;
    ...

Note: This is a Typescript feature. If using the logger is desired in Javascript you should simply retrieve the singleton instance via Logger.instance()

Object containing options for controlling how command arguments will be parsed

Valid argument resolver types for use with resolve and expect. Can be one of the following string literals:

'String'
| 'Number'
| 'Boolean'
| 'Duration'
| 'User'
| 'Member'
| 'BannedUser'
| 'Channel'
| 'Role'
| 'Command'
| 'CommandGroup'
| 'Any'

or an Array of possible string literal values

Enum containing all base framework localization string keys

Object containing required Command properties to be passed to a Command on construction

The default settings to apply to new guilds. Stored under the key 'defaultGuildSettings' in Client#storage

Represents a difference between two given valid Unix time signatures

Represents an object containing localization overrides for a command's desc, info, and usage fields

Represents an object passed from the Logger to the TransportFunction of any Transports given to it

Enum containing the different levels of potential logger output. Each level represents itself and everything above it in the enum. The default logger log level is LogLevel.LOG

enum LogLevel
{
    NONE,
    LOG,
    INFO,
    WARN,
    ERROR.
    DEBUG
}

A function that takes a Message object and an array of args, does anything with them, and returns a Tuple where the first item is the Message object and the second item is the array of args

(Message, any[]) => [Message, any[]]

Can be async as long as the returned promise resolves with the tuple containing the message object and the args array as expected.

If a middleware function returns a string, or throws a string/error, it will be sent to the calling channel as a message and the Command execution will be aborted. If a middleware function does not return anything or returns something other than an array or string, the Command will fail silently.

Note: The command dispatcher will attempt to bind the Command instance to the middleware function when called, so this within a middleware function (if it is not an arrow function) will be the Command instance at runtime

Any class that extends and implements Plugin. Not to be confused with an instance of a Plugin.

Any class that extends and implements Resolver. Not to be confused with an instance of a Resolver.

Represents a function assigned to a specific language that takes a string key and an optional TemplateData object and returns a localized string for that language if it exists

A Proxy where calling functions will treat the function name as a Lang string key and act as a ResourceLoader, requiring only the strings TemplateData (or nothing for non-dynamic strings)

TypeScript users can pass a generic type parameter to the ResourceProxy type which will append all the keys of the passed type to the valid keys on the ResourceProxy itself. This makes it easier to get type hinting for custom localization strings. Example:

type C = {
    FOO: any;
    BAR: any;
};
...
let r: ResourceProxy<C> = Lang.createResourceProxy('en_us');
return r.FOO(); // `FOO` will be of type `(data?: TemplateData) => string`
                // so this returns a string

Object consisting of MessageOptions and an optional button string field for compact mode support

Any class that extends and implements StorageProvider and provides an interface with a storage medium allowing data to be stored, retrieved, and manipulated. Not to be confused with an instance of a storage provider.

Represents an object mapping template keys to values, where the template keys will be replaced with the provided values in the source string when given to a Lang resource function/proxy like Lang.res()

Represents a transport object for the Logger.

Represents a function to be included in a Transport object. This function will be given a LogData object at runtime whenever a logger method is called. What is done with that log data is entirely up to you as the developer, but logging to a file. to a database, or even to a Discord channel would be some good examples

Represents an array of fixed length where the the item in the specified position is of the specified type.

Example:

['foo', 10] === [string, number] === Tuple<string, number>

Object containing required Client properties to be passed to a Client on construction