Understanding 'declare module'

Clients

Seyfert provides several client types to instantiate your bot, which could cause confusion when referencing the client in different parts of your code. To avoid this, you can specify the client type you're using to TypeScript. Be sure to choose only one of the following three implementations:

import type { ParseClient, Client, HttpClient, WorkerClient } from 'seyfert';
 
declare module 'seyfert' {
 
    interface UsingClient extends ParseClient<Client<true>> { } // Gateway
  
  
    interface UsingClient extends ParseClient<HttpClient> { } // HTTP
  
  
    interface UsingClient extends ParseClient<WorkerClient<true>> { } // Worker
}

Middlewares

To use your middlewares throughout the project, you need to inform TypeScript about their structure and composition. Export all middlewares from your code and provide them to Seyfert as follows:

// Assuming you exported all middlewares from './middlewares';
import type * as allMiddlewares from './middlewares';
 
declare module 'seyfert' {
    interface RegisteredMiddlewares extends ParseMiddlewares<typeof allMiddlewares> {} 
}

This applies similarly to global middlewares, which are automatically executed on every command, even if they aren't explicitly specified in it.

// Assuming you exported all global middlewares from './globalMiddlewares';
import type * as globalMiddlewares from './globalMiddlewares';
 
declare module 'seyfert' {
    interface GlobalMetadata extends ParseMiddlewares<typeof globalMiddlewares> {} 
}

Languages

To correctly configure types for languages, it's recommended to establish a primary or base language that you always update. This way, all types will derive from this language, making it easier to keep the rest of the translations up to date.

// Assuming your base language is located in './langs/en';
import type * as defaultLang from './langs/en';
 
declare module 'seyfert' {
    interface DefaultLocale extends ParseLocales<typeof defaultLang> {} 
}

Contexts

We often need to extend contexts to add useful properties or methods, which also requires updating the types.

If you've used extendContext for this, you can use the following code to infer the type returned by your function and add it to the context:

import { extendContext } from 'seyfert';
 
const context = extendContext((ctx) => ({ otter: 'cute' }));
 
declare module 'seyfert' {
    interface ExtendContext extends ReturnType<typeof context> {} 
}

Command Properties

We often need to categorize some commands or simply assign an identifier for something.

To achieve this, we can use ExtraProps:

const client = new Client({
    commands: {
        defaults: {
            props: {
Property 'onlyForAdmins' is missing in type '{ category: string; }' but required in type 'ExtraProps'.
                category: 'none'
            }
        }
    }
});
 
@Declare({
    name: 'test',
    description: 'test command',
    props: {}
Property 'onlyForAdmins' is missing in type '{}' but required in type 'ExtraProps'.
})
class Test extends Command {}
 
declare module 'seyfert' {
    interface ExtraProps {
        onlyForAdmins: boolean;
        disabled?: true;
        category?: string
    }
}

Internal Options

Since Seyfert supports various modes of operation, it's necessary to add types as required by your implementations. For this, InternalOptions exists as an interface designed to include properties that transform Seyfert types into something more comprehensive.

declare module 'seyfert' {
    interface InternalOptions {
        withPrefix: true; // or false
        asyncCache: false; // or true
    }
}

withPrefix

Setting this property to true tells Seyfert that the context can include either a message or an interaction, both of which will be optional. By default, .interaction is always present in the context.

asyncCache

Setting this property to true tells Seyfert whether the cache will return a promise. By default, Seyfert uses MemoryAdapter, a RAM cache that doesn't return promises, while RedisAdapter does.

Configuration

In Seyfert, you can add more properties to the configuration file seyfert.config.mjs, regardless of whether you're using the http or bot configuration. This can be done using ExtendedRC as follows:

declare module 'seyfert' {
    interface ExtendedRC {
        developers: string[];
        // more properties here...
    }
}

Locations

Just as you can extend Seyfert's base configuration, you can also extend the folder locations object using ExtendedRCLocations. This can be done as follows:

declare module 'seyfert' {
    interface ExtendedRCLocations {
        models: string;
        // more properties here...
    }
}