@mostfeatured/dbi 0.2.11 → 0.2.13

package/llm.txt

@@ -0,0 +1,1088 @@
+# DBI - Discord Bot Infrastructure
+
+> The most advanced, modern, and developer-friendly Discord bot framework available.
+> NPM Package: @mostfeatured/dbi
+
+## Overview
+
+DBI (Discord Bot Infrastructure) is a powerful NPM module that provides a complete infrastructure for building production-ready Discord bots with minimal boilerplate. It wraps Discord.js v14 and provides type-safe, structured patterns for building scalable bots.
+
+## Key Features
+
+- **Slash Commands**: Full support for Discord's application commands with type-safe options
+- **Components V2**: Buttons, Select Menus, Modals with built-in state management
+- **Svelte Integration**: Build reactive Discord UIs with Svelte 5 components
+- **Localization**: Multi-language support for both content and interactions
+- **Message Commands**: Automatic slash-to-message command conversion
+- **Reference System**: Pass complex data through components without database
+- **Rate Limiting**: Built-in per-user, channel, guild rate limiting
+- **Multi-Client**: Support for multiple bot clients simultaneously
+- **Hybrid Sharding**: Built-in support for discord-hybrid-sharding
+- **Type Safety**: Full TypeScript support with intelligent autocomplete
+
+## Installation
+
+```bash
+npm install @mostfeatured/dbi discord.js
+# or
+pnpm add @mostfeatured/dbi discord.js
+```
+
+## Project Structure
+
+```
+my-bot/
+├── dbi.js          # DBI configuration
+├── login.js        # Bot startup script
+├── publish.js      # Command publishing script
+└── src/
+    ├── commands/   # Slash commands
+    ├── events/     # Discord event handlers
+    ├── components/ # Buttons, Select Menus, Modals
+    └── locales/    # Language files
+```
+
+---
+
+## Core Concepts
+
+### 1. Creating DBI Instance
+
+```javascript
+const { createDBI } = require("@mostfeatured/dbi");
+
+const dbi = createDBI("my-bot", {
+  strict: true,
+  discord: {
+    token: process.env.DISCORD_TOKEN,
+    options: {
+      intents: ["Guilds", "GuildMessages", "MessageContent"]
+    }
+  },
+  defaults: {
+    locale: { name: "en" },
+    defaultMemberPermissions: ["SendMessages"],
+    directMessages: false
+  },
+  references: {
+    autoClear: {
+      ttl: 60 * 60 * 1000,  // 1 hour
+      check: 60 * 1000      // Check every minute
+    }
+  },
+  inlineListeners: {
+    autoClear: {
+      ttl: 15 * 60 * 1000,  // 15 minutes
+      check: 60 * 1000
+    }
+  }
+});
+
+module.exports = dbi;
+```
+
+### 2. The Register Pattern
+
+DBI uses a register pattern to define all bot features:
+
+```javascript
+dbi.register(({ ChatInput, Button, Event, Locale }) => {
+  ChatInput({ /* ... */ });
+  Button({ /* ... */ });
+  Event({ /* ... */ });
+  Locale({ /* ... */ });
+});
+```
+
+Available register functions:
+- `ChatInput` - Slash commands
+- `Button` - Button components
+- `StringSelectMenu`, `UserSelectMenu`, `RoleSelectMenu`, `ChannelSelectMenu`, `MentionableSelectMenu` - Select menus
+- `Modal` - Modal dialogs
+- `MessageContextMenu`, `UserContextMenu` - Context menu commands
+- `Event` - Discord events
+- `Locale` - Content localization
+- `InteractionLocale` - Interaction name localization
+- `CustomEvent` - Custom event definitions
+- `HTMLComponentsV2` - Svelte/Eta template components
+- `ChatInputOptions` - Command option builders
+- `onUnload` - Cleanup callback for hot reloading
+
+### 3. Starting the Bot
+
+```javascript
+const { Utils } = require("@mostfeatured/dbi");
+const dbi = require("./dbi");
+
+async function start() {
+  await Utils.recursiveImport("./src");  // Import all files
+  await dbi.load();                       // Load features
+  await dbi.login();                      // Connect to Discord
+}
+start();
+```
+
+### 4. Publishing Commands
+
+```javascript
+const { Utils } = require("@mostfeatured/dbi");
+const dbi = require("./dbi");
+
+async function publish() {
+  await Utils.recursiveImport("./src");
+  await dbi.load();
+  
+  // Development: Guild-specific (instant)
+  await dbi.publish("Guild", "YOUR_GUILD_ID");
+  
+  // Production: Global (up to 1 hour delay)
+  // await dbi.publish("Global");
+  
+  await dbi.unload();
+}
+publish();
+```
+
+---
+
+## Chat Input Commands (Slash Commands)
+
+### Basic Command
+
+```javascript
+dbi.register(({ ChatInput }) => {
+  ChatInput({
+    name: "ping",
+    description: "Check the bot's latency",
+    async onExecute({ interaction, dbi }) {
+      const latency = dbi.client().client.ws.ping;
+      await interaction.reply(`🏓 Pong! Latency: ${latency}ms`);
+    }
+  });
+});
+```
+
+### Command Options
+
+```javascript
+dbi.register(({ ChatInput, ChatInputOptions }) => {
+  ChatInput({
+    name: "greet",
+    description: "Greet someone",
+    options: [
+      ChatInputOptions.user({
+        name: "user",
+        description: "User to greet",
+        required: true
+      }),
+      ChatInputOptions.string({
+        name: "message",
+        description: "Custom message",
+        required: false,
+        minLength: 1,
+        maxLength: 200
+      }),
+      ChatInputOptions.boolean({
+        name: "mention",
+        description: "Mention the user?",
+        required: false
+      })
+    ],
+    onExecute({ interaction }) {
+      const user = interaction.options.getUser("user");
+      const message = interaction.options.getString("message") || "Hello!";
+      const mention = interaction.options.getBoolean("mention");
+      
+      interaction.reply(mention ? `${user} ${message}` : `${user.username}: ${message}`);
+    }
+  });
+});
+```
+
+### ChatInputOptions Methods
+
+| Method | Description |
+|--------|-------------|
+| `string()` | Free text input |
+| `stringChoices()` | Text with predefined choices |
+| `stringAutocomplete()` | Text with dynamic autocomplete |
+| `integer()` | Whole number |
+| `integerChoices()` | Integer with choices |
+| `integerAutocomplete()` | Integer with autocomplete |
+| `number()` | Decimal number |
+| `numberChoices()` | Number with choices |
+| `numberAutocomplete()` | Number with autocomplete |
+| `boolean()` | True/false |
+| `user()` | User mention |
+| `channel()` | Channel mention (supports `channelTypes[]`) |
+| `role()` | Role mention |
+| `mentionable()` | User or role |
+| `attachment()` | File upload |
+
+### Autocomplete
+
+```javascript
+ChatInputOptions.stringAutocomplete({
+  name: "item",
+  description: "Search for an item",
+  required: true,
+  async onComplete({ value, interaction }) {
+    const items = await searchDatabase(value);
+    return items.slice(0, 25).map(item => ({
+      name: item.displayName,
+      value: item.id
+    }));
+  }
+})
+```
+
+### Subcommands
+
+```javascript
+const Discord = require("discord.js");
+
+ChatInput({
+  name: "config",
+  description: "Bot configuration",
+  options: [
+    {
+      type: Discord.ApplicationCommandOptionType.Subcommand,
+      name: "view",
+      description: "View configuration"
+    },
+    {
+      type: Discord.ApplicationCommandOptionType.Subcommand,
+      name: "set",
+      description: "Change a setting",
+      options: [
+        ChatInputOptions.string({ name: "key", description: "Setting name", required: true }),
+        ChatInputOptions.string({ name: "value", description: "New value", required: true })
+      ]
+    }
+  ],
+  onExecute({ interaction }) {
+    const subcommand = interaction.options.getSubcommand();
+    // Handle based on subcommand
+  }
+});
+```
+
+### Permissions
+
+```javascript
+ChatInput({
+  name: "ban",
+  description: "Ban a user",
+  defaultMemberPermissions: ["BanMembers"],  // Required permission
+  directMessages: false,  // Disable in DMs
+  onExecute({ interaction }) { /* ... */ }
+});
+```
+
+### Context Menus
+
+```javascript
+// Message Context Menu (right-click on message)
+dbi.register(({ MessageContextMenu }) => {
+  MessageContextMenu({
+    name: "Report Message",
+    async onExecute({ interaction }) {
+      const message = interaction.targetMessage;
+      await interaction.reply({ content: `Reported: ${message.id}`, ephemeral: true });
+    }
+  });
+});
+
+// User Context Menu (right-click on user)
+dbi.register(({ UserContextMenu }) => {
+  UserContextMenu({
+    name: "View Profile",
+    async onExecute({ interaction }) {
+      const user = interaction.targetUser;
+      await interaction.reply({ content: `Profile: ${user.tag}`, ephemeral: true });
+    }
+  });
+});
+```
+
+---
+
+## Components
+
+### Buttons
+
+```javascript
+const Discord = require("discord.js");
+
+dbi.register(({ ChatInput, Button }) => {
+  Button({
+    name: "action-btn",
+    options: {
+      style: Discord.ButtonStyle.Primary,
+      label: "Click Me",
+      emoji: "👋"
+    },
+    onExecute({ interaction, data }) {
+      const [action] = data;  // Access referenced data
+      interaction.reply({ content: `Action: ${action}`, ephemeral: true });
+    }
+  });
+
+  ChatInput({
+    name: "actions",
+    description: "Show action buttons",
+    onExecute({ interaction, dbi }) {
+      const button = dbi.interaction("action-btn");
+      
+      interaction.reply({
+        content: "Choose an action:",
+        components: [{
+          type: Discord.ComponentType.ActionRow,
+          components: [
+            button.toJSON({
+              overrides: { label: "Accept", style: Discord.ButtonStyle.Success },
+              reference: { data: ["accept"] }
+            }),
+            button.toJSON({
+              overrides: { label: "Decline", style: Discord.ButtonStyle.Danger },
+              reference: { data: ["decline"] }
+            })
+          ]
+        }]
+      });
+    }
+  });
+});
+```
+
+Button Styles: `Primary`, `Secondary`, `Success`, `Danger`, `Link`, `Premium`
+
+### Select Menus
+
+```javascript
+dbi.register(({ StringSelectMenu }) => {
+  StringSelectMenu({
+    name: "color-select",
+    options: {
+      placeholder: "Choose a color...",
+      minValues: 1,
+      maxValues: 1,
+      options: [
+        { label: "Red", value: "red", emoji: "🔴", description: "A warm color" },
+        { label: "Green", value: "green", emoji: "🟢" },
+        { label: "Blue", value: "blue", emoji: "🔵" }
+      ]
+    },
+    onExecute({ interaction }) {
+      const selected = interaction.values[0];
+      interaction.reply(`You selected: ${selected}`);
+    }
+  });
+});
+
+// Other select menu types
+UserSelectMenu({ /* ... */ });      // Select users
+RoleSelectMenu({ /* ... */ });      // Select roles
+ChannelSelectMenu({ /* ... */ });   // Select channels
+MentionableSelectMenu({ /* ... */ }); // Select users or roles
+```
+
+### Modals
+
+```javascript
+dbi.register(({ Modal, Button }) => {
+  Modal({
+    name: "feedback-modal",
+    options: {
+      title: "Send Feedback",
+      components: [
+        {
+          type: Discord.ComponentType.ActionRow,
+          components: [{
+            type: Discord.ComponentType.TextInput,
+            customId: "subject",
+            label: "Subject",
+            style: Discord.TextInputStyle.Short,
+            placeholder: "Brief description",
+            required: true,
+            minLength: 5,
+            maxLength: 100
+          }]
+        },
+        {
+          type: Discord.ComponentType.ActionRow,
+          components: [{
+            type: Discord.ComponentType.TextInput,
+            customId: "message",
+            label: "Message",
+            style: Discord.TextInputStyle.Paragraph,
+            placeholder: "Your detailed feedback...",
+            required: true
+          }]
+        }
+      ]
+    },
+    async onExecute({ interaction }) {
+      const subject = interaction.fields.getTextInputValue("subject");
+      const message = interaction.fields.getTextInputValue("message");
+      await interaction.reply({ content: "Thanks for your feedback!", ephemeral: true });
+    }
+  });
+
+  Button({
+    name: "open-feedback",
+    options: { style: Discord.ButtonStyle.Primary, label: "Feedback" },
+    async onExecute({ interaction, dbi }) {
+      const modal = dbi.interaction("feedback-modal").toJSON();
+      await interaction.showModal(modal);
+    }
+  });
+});
+```
+
+### Reference System
+
+Pass data through components without database:
+
+```javascript
+// Primitive values are encoded in custom ID
+button.toJSON({
+  reference: {
+    data: ["userId123", 42, true]  // string, number, boolean
+  }
+});
+
+// Objects are stored in memory with auto-cleanup
+button.toJSON({
+  reference: {
+    data: [{ complex: "object", nested: { data: true } }],
+    ttl: 300000  // Auto-expire in 5 minutes
+  }
+});
+
+// Access in handler
+Button({
+  name: "my-btn",
+  onExecute({ data }) {
+    const [primitiveOrObject] = data;
+    
+    // If object, has $ref and $unRef
+    if (primitiveOrObject?.$ref) {
+      console.log(primitiveOrObject.$ref);  // Reference ID
+      primitiveOrObject.$unRef();  // Clean up when done
+    }
+  }
+});
+```
+
+### Inline Components
+
+Create one-time use components without pre-registration:
+
+```javascript
+dbi.register(({ ChatInput, createInlineButton, createInlineStringSelectMenu }) => {
+  ChatInput({
+    name: "confirm",
+    description: "Confirm an action",
+    async onExecute({ interaction }) {
+      const confirmBtn = createInlineButton({
+        options: { style: Discord.ButtonStyle.Success, label: "Confirm" },
+        onExecute({ interaction }) {
+          interaction.reply("Confirmed!");
+        }
+      });
+      
+      const cancelBtn = createInlineButton({
+        options: { style: Discord.ButtonStyle.Danger, label: "Cancel" },
+        onExecute({ interaction }) {
+          interaction.reply("Cancelled!");
+        }
+      });
+      
+      await interaction.reply({
+        content: "Are you sure?",
+        components: [{
+          type: Discord.ComponentType.ActionRow,
+          components: [confirmBtn.toJSON(), cancelBtn.toJSON()]
+        }]
+      });
+    }
+  });
+});
+```
+
+Inline creators: `createInlineButton`, `createInlineStringSelectMenu`, `createInlineUserSelectMenu`, `createInlineRoleSelectMenu`, `createInlineChannelSelectMenu`, `createInlineMentionableSelectMenu`, `createInlineModal`, `createInlineEvent`
+
+---
+
+## Events
+
+### Basic Event Handler
+
+```javascript
+dbi.register(({ Event }) => {
+  Event({
+    name: "clientReady",
+    id: "ready-logger",  // Unique ID for multiple handlers of same event
+    onExecute({ client }) {
+      console.log(`Bot is online as ${client.user.tag}`);
+    }
+  });
+
+  Event({
+    name: "messageCreate",
+    id: "message-handler",
+    onExecute({ message }) {
+      if (message.author.bot) return;
+      console.log(`${message.author.tag}: ${message.content}`);
+    }
+  });
+
+  Event({
+    name: "guildMemberAdd",
+    id: "welcome",
+    async onExecute({ member }) {
+      const channel = member.guild.systemChannel;
+      if (channel) await channel.send(`Welcome ${member}!`);
+    }
+  });
+});
+```
+
+### Common Events
+
+| Event Name | Parameters |
+|------------|------------|
+| `clientReady` | `{ client }` |
+| `messageCreate` | `{ message }` |
+| `messageDelete` | `{ message }` |
+| `messageUpdate` | `{ oldMessage, newMessage }` |
+| `guildCreate` | `{ guild }` |
+| `guildDelete` | `{ guild }` |
+| `guildMemberAdd` | `{ member }` |
+| `guildMemberRemove` | `{ member }` |
+| `interactionCreate` | `{ interaction }` |
+| `voiceStateUpdate` | `{ oldState, newState }` |
+
+### Custom Events
+
+```javascript
+dbi.register(({ CustomEvent, Event }) => {
+  CustomEvent({
+    name: "userLevelUp",
+    map: { userId: "userId", newLevel: "newLevel", guild: "guild" }
+  });
+
+  Event({
+    name: "userLevelUp",
+    id: "levelup-announcer",
+    onExecute({ userId, newLevel, guild }) {
+      guild.systemChannel?.send(`🎉 <@${userId}> reached level ${newLevel}!`);
+    }
+  });
+});
+
+// Trigger from anywhere
+dbi.emit("userLevelUp", { userId: "123", newLevel: 10, guild: someGuild });
+```
+
+### DBI Internal Events
+
+```javascript
+dbi.events.on("beforeInteraction", async (ctx) => {
+  console.log(`Interaction: ${ctx.dbiInteraction.name}`);
+  return true;  // Continue execution
+});
+
+dbi.events.on("afterInteraction", async (ctx) => {
+  console.log(`Completed: ${ctx.dbiInteraction.name}`);
+  return true;
+});
+
+dbi.events.on("interactionError", async ({ interaction, error }) => {
+  console.error("Error:", error);
+  await interaction.reply({ content: "An error occurred.", ephemeral: true });
+  return true;
+});
+
+dbi.events.on("interactionRateLimit", async ({ interaction, remainingTime }) => {
+  const seconds = Math.ceil(remainingTime / 1000);
+  await interaction.reply({ content: `Cooldown: ${seconds}s`, ephemeral: true });
+  return false;  // Don't execute
+});
+```
+
+---
+
+## Localization
+
+### Content Localization
+
+```javascript
+dbi.register(({ Locale }) => {
+  Locale({
+    name: "en",
+    data: {
+      greeting: "Hello!",
+      welcome: "Welcome, {0}!",
+      levelUp: "{0} reached level {1}!",
+      commands: {
+        help: { title: "Help Menu", description: "Available commands:" }
+      }
+    }
+  });
+
+  Locale({
+    name: "tr",
+    data: {
+      greeting: "Merhaba!",
+      welcome: "Hoş geldin, {0}!",
+      levelUp: "{0} seviye {1}'e ulaştı!",
+      commands: {
+        help: { title: "Yardım Menüsü", description: "Mevcut komutlar:" }
+      }
+    }
+  });
+});
+```
+
+### Using Locales
+
+```javascript
+ChatInput({
+  name: "greet",
+  description: "Greet the user",
+  onExecute({ interaction, locale }) {
+    // User's locale (based on Discord client language)
+    const greeting = locale.user.data.greeting();
+    const welcome = locale.user.data.welcome(interaction.user.username);
+    const title = locale.user.data.commands.help.title();
+    
+    // Guild's locale
+    const guildGreeting = locale.guild?.data.greeting?.();
+    
+    interaction.reply(welcome);
+  }
+});
+
+// Access specific locale
+const enLocale = dbi.locale("en");
+const message = enLocale.data.levelUp("John", 10);
+```
+
+### Interaction Localization (Command Translations)
+
+```javascript
+dbi.register(({ ChatInput, InteractionLocale }) => {
+  ChatInput({
+    name: "ayarlar",  // Turkish default
+    description: "Bot ayarlarını değiştir",
+    onExecute({ interaction }) { /* ... */ }
+  });
+
+  InteractionLocale({
+    name: "ayarlar",
+    data: {
+      en: {
+        name: "settings",
+        description: "Change bot settings",
+        options: {
+          dil: {
+            name: "language",
+            description: "Preferred language"
+          }
+        }
+      },
+      es: {
+        name: "ajustes",
+        description: "Cambiar configuración del bot"
+      }
+    }
+  });
+});
+```
+
+---
+
+## Svelte Components (HTMLComponentsV2)
+
+Build reactive Discord UIs with Svelte 5:
+
+### Registration
+
+```javascript
+const path = require("path");
+
+dbi.register(({ HTMLComponentsV2, ChatInput }) => {
+  HTMLComponentsV2({
+    name: "counter",
+    mode: "svelte",
+    file: path.join(__dirname, "counter.svelte")
+  });
+
+  ChatInput({
+    name: "counter",
+    description: "Interactive counter",
+    async onExecute({ interaction, dbi }) {
+      const component = dbi.interaction("counter");
+      await component.send(interaction, {
+        data: { count: 0 }
+      });
+    }
+  });
+});
+```
+
+### Svelte Component (counter.svelte)
+
+```svelte
+<script>
+  /// <reference types="@mostfeatured/dbi/svelte" />
+  
+  let { count = 0 } = $props();
+
+  function increment() {
+    data.count++;
+  }
+
+  function decrement() {
+    data.count--;
+  }
+
+  function reset(ctx) {
+    data.count = 0;
+    ctx.interaction.reply({ content: "Reset!", flags: ["Ephemeral"] });
+  }
+
+  onMount(() => {
+    const interval = setInterval(() => {
+      // Auto-updates component every second
+    }, 1000);
+    return () => clearInterval(interval);  // Cleanup
+  });
+</script>
+
+<components>
+  <container accent-color="5865F2">
+    <components>
+      <text-display>## Counter: {count}</text-display>
+      <action-row>
+        <button style="Primary" handler={decrement}>-1</button>
+        <button style="Primary" handler={increment}>+1</button>
+        <button style="Danger" handler={reset}>Reset</button>
+      </action-row>
+    </components>
+  </container>
+</components>
+```
+
+### Svelte HTML Elements
+
+Layout:
+- `<components>` - Root wrapper
+- `<action-row>` - Container for buttons (max 5) or single select menu
+- `<container accent-color="hex" spoiler>` - Colored container
+- `<section>` - Section with components and accessory
+- `<separator divider spacing="1-3">` - Visual divider
+
+Interactive:
+- `<button style="Primary|Secondary|Success|Danger|Link|Premium" handler={fn} emoji="🎉" disabled>Label</button>`
+- `<string-select placeholder="..." min-values="1" max-values="3" handler={fn}>`
+- `<option value="x" description="..." emoji="..." default>Label</option>`
+- `<user-select>`, `<role-select>`, `<channel-select>`, `<mentionable-select>`
+
+Display:
+- `<text-display>Markdown content</text-display>`
+- `<thumbnail url="...">` or `<thumbnail media="...">`
+- `<media-gallery>` with `<item url="..." description="..." spoiler>`
+- `<file url="attachment://file.pdf" spoiler>`
+
+Modal:
+- `<text-input id="..." label="..." placeholder="..." style="Short|Paragraph" min-length="1" max-length="100" required>Default</text-input>`
+
+### Svelte Globals
+
+```javascript
+// Reactive data updates
+data.property = newValue;  // Triggers re-render
+
+// Render control
+render();        // Force immediate render
+update();        // Use interaction.update()
+rerender();      // Use message.edit()
+noRender();      // Disable auto-render for this handler
+setThrottle(ms); // Set min interval between renders
+
+// Lifecycle
+onMount(() => { return cleanup; });
+onDestroy(() => { /* cleanup */ });
+destroy();       // Manually destroy component
+```
+
+---
+
+## Rate Limiting
+
+### Declarative Rate Limits
+
+```javascript
+ChatInput({
+  name: "daily",
+  description: "Daily reward",
+  rateLimits: [
+    { type: "User", duration: 86400000 }  // 24 hours
+  ],
+  onExecute({ interaction }) {
+    interaction.reply("Here's your daily reward!");
+  }
+});
+```
+
+Rate Limit Types: `User`, `Channel`, `Guild`, `Member`, `Message`
+
+### Dynamic Rate Limits
+
+```javascript
+ChatInput({
+  name: "action",
+  description: "Do something",
+  async onExecute({ interaction, setRateLimit }) {
+    const isPremium = await checkPremium(interaction.user.id);
+    await setRateLimit("User", isPremium ? 30000 : 300000);
+    interaction.reply("Done!");
+  }
+});
+```
+
+---
+
+## Message Commands
+
+Enable prefix-based commands that mirror slash commands:
+
+```javascript
+const dbi = createDBI("my-bot", {
+  discord: { /* ... */ },
+  messageCommands: {
+    prefixes: ["!", ".", "?"],
+    // Or dynamic: async ({ message }) => [await getGuildPrefix(message.guild?.id)]
+    typeAliases: {
+      booleans: { "yes": true, "no": false, "on": true, "off": false }
+    }
+  },
+  defaults: {
+    messageCommands: {
+      deferReplyContent: "Processing..."
+    }
+  }
+});
+```
+
+Usage: `!ping`, `!greet @User Hello!`
+
+### Aliases and Rest Arguments
+
+```javascript
+ChatInput({
+  name: "help",
+  description: "Show help",
+  other: {
+    messageCommand: {
+      aliases: ["h", "?", "commands"],
+      ignore: false  // Set true to disable message command
+    }
+  },
+  onExecute({ interaction }) { /* ... */ }
+});
+
+// Rest string (captures all remaining text)
+ChatInputOptions.string({
+  name: "message",
+  description: "The message",
+  required: true,
+  messageCommands: { rest: true }
+})
+```
+
+---
+
+## Multi-Client Support
+
+```javascript
+const dbi = createDBI("my-bot", {
+  discord: [
+    { namespace: "main", token: process.env.MAIN_TOKEN, options: { intents: ["Guilds"] } },
+    { namespace: "music", token: process.env.MUSIC_TOKEN, options: { intents: ["GuildVoiceStates"] } }
+  ]
+});
+
+// Access clients
+const mainClient = dbi.client("main");
+const musicClient = dbi.client("music");
+
+// Publish to specific client
+ChatInput({
+  name: "play",
+  description: "Play music",
+  publish: "music",  // Only on music bot
+  onExecute({ clientNamespace }) { /* ... */ }
+});
+```
+
+---
+
+## Sharding
+
+```javascript
+// Default sharding
+const dbi = createDBI("my-bot", { sharding: "default", /* ... */ });
+
+// Hybrid sharding (discord-hybrid-sharding)
+const dbi = createDBI("my-bot", { sharding: "hybrid", /* ... */ });
+
+// Access cluster info
+if (dbi.cluster) {
+  console.log(`Cluster: ${dbi.cluster.id}, Shards: ${dbi.cluster.shards}`);
+}
+```
+
+---
+
+## Hot Reloading
+
+```javascript
+dbi.register(({ ChatInput, Event, onUnload }) => {
+  let interval;
+
+  Event({
+    name: "clientReady",
+    id: "updater",
+    onExecute() {
+      interval = setInterval(() => { /* ... */ }, 60000);
+    }
+  });
+
+  onUnload(() => {
+    if (interval) clearInterval(interval);
+    console.log("Cleaned up!");
+  });
+});
+
+// Reload flow
+await dbi.unload();
+Utils.recursiveUnload("./src");
+await Utils.recursiveImport("./src");
+await dbi.load();
+```
+
+---
+
+## Flag-based Loading
+
+```javascript
+ChatInput({
+  name: "debug-info",
+  description: "Debug information",
+  flag: "debug",  // Only loaded with debug flag
+  onExecute({ interaction }) { /* ... */ }
+});
+
+// Load with specific flags
+await dbi.load("debug");
+await dbi.load("debug", "admin");
+await dbi.load("all");  // Load everything
+await dbi.load();       // Only non-flagged features
+```
+
+---
+
+## Data Management
+
+```javascript
+// Store/retrieve data
+dbi.set("config", { prefix: "!" });
+const config = dbi.get("config");
+dbi.has("config");
+dbi.delete("config");
+
+// Access registered features
+const pingCmd = dbi.interaction("ping");
+const readyEvent = dbi.event("ready-handler");
+const enLocale = dbi.locale("en");
+
+// Access collections
+dbi.data.interactions;  // Discord.Collection
+dbi.data.events;
+dbi.data.locales;
+dbi.data.refs;          // Reference storage
+```
+
+---
+
+## Execution Context
+
+All handlers receive a context object:
+
+```javascript
+onExecute({
+  interaction,       // Discord.js interaction
+  dbi,               // DBI instance
+  dbiInteraction,    // The registered interaction object
+  locale,            // { user: DBILocale, guild?: DBILocale }
+  setRateLimit,      // (type, duration) => Promise<void>
+  other,             // Custom shared data
+  clientNamespace,   // Multi-client namespace
+  v2,                // Components V2 enabled
+  data               // Referenced data array (components only)
+}) { /* ... */ }
+```
+
+---
+
+## API Quick Reference
+
+### DBI Instance Methods
+
+| Method | Description |
+|--------|-------------|
+| `register(callback)` | Register bot features |
+| `load(...flags)` | Load registered features |
+| `unload()` | Unload all features |
+| `login()` | Connect to Discord |
+| `publish(type, guildId?)` | Publish commands |
+| `interaction(name)` | Get registered interaction |
+| `event(name)` | Get registered event |
+| `locale(name)` | Get registered locale |
+| `client(namespace?)` | Get client |
+| `emit(name, args)` | Emit custom event |
+| `get/set/has/delete` | Data management |
+
+### Interaction Methods
+
+| Method | Description |
+|--------|-------------|
+| `toJSON(args?)` | Get JSON for Discord API |
+| `createBuilder()` | Get fluent builder |
+
+### Component Builder Methods
+
+| Method | Description |
+|--------|-------------|
+| `setLabel(label)` | Set button label |
+| `setEmoji(emoji)` | Set emoji |
+| `setStyle(style)` | Set style |
+| `setReference(data)` | Set reference data |
+| `setTTL(ms)` | Set time-to-live |
+| `toJSON()` | Build final JSON |
+
+---
+
+## License
+
+GPL-3.0 License
+
+---
+
+Made by TheArmagan and the MostFeatured team
+Package: @mostfeatured/dbi
+GitHub: https://github.com/MostFeatured/DiscordBotInfrastructure