Types

type Platform = "kick" | "twitch" | "youtube" | "rumble" | "tiktok";

import type { Platform } from './types/streamer.js';

const platform: Platform = 'twitch';

interface Streamer {
  id: string;
  platform: Platform;
  username: string;
  displayName?: string;
  channelId: string;
  isLive: boolean;
  lastLiveAt?: string;
  title?: string;
  viewers?: number;
  followers?: number;
  thumbnail?: string;
  profileImage?: string;
  startedAt?: string;
  verified?: boolean;
  bio?: string;
}

import type { Streamer } from './types/streamer.js';

const streamer: Streamer = {
  id: 'twitch:xqc',
  platform: 'twitch',
  username: 'xqc',
  displayName: 'xQc',
  channelId: '123456789',
  isLive: true,
  lastLiveAt: '2026-03-01T12:00:00.000Z',
  title: 'VALORANT RANKED',
  viewers: 50000,
  followers: 2000000,
  profileImage: 'https://static-cdn.jtvnw.net/...',
  thumbnail: 'https://static-cdn.jtvnw.net/...',
  startedAt: '2026-03-01T10:30:00.000Z',
  verified: true,
  bio: 'Variety streamer',
};

interface LiveStatus {
  isLive: boolean;
  platform: Platform;
  username: string;
  title?: string;
  viewers?: number;
  followers?: number;
  thumbnail?: string;
  profileImage?: string;
  startedAt?: string;
  url: string;
  verified?: boolean;
  bio?: string;
  category?: string;
  categoryIcon?: string;
  tags?: string[];
  language?: string;
  isMature?: boolean;
  error?: string;
}

import type { LiveStatus } from './types/streamer.js';
import { checkTwitchLive } from './platforms/twitch.js';

const status: LiveStatus = await checkTwitchLive('xqc');

if (status.isLive) {
  console.log(`${status.username} is live!`);
  console.log(`Title: ${status.title}`);
  console.log(`Viewers: ${status.viewers}`);
  console.log(`Game: ${status.category}`);
  console.log(`URL: ${status.url}`);
}

interface GuildSettings {
  streamers: Streamer[];
}

import type { GuildSettings } from './types/streamer.js';
import { getGuildSettings } from './database/index.js';

const settings: GuildSettings = getGuildSettings('123456789');

console.log(`Tracking ${settings.streamers.length} streamers`);
settings.streamers.forEach(s => {
  console.log(`  - ${s.username} on ${s.platform}`);
});

type PlatformChecker = (username: string) => Promise<LiveStatus>;

import type { PlatformChecker } from './types/streamer.js';
import { checkKickLive } from './platforms/kick.js';

const checker: PlatformChecker = checkKickLive;

const status = await checker('trainwreckstv');
console.log(status.isLive);

interface PlatformConfig {
  name: string;
  color: number;
  emoji: string;
  urlTemplate: string;
  checker: PlatformChecker;
}

import type { PlatformConfig } from './types/streamer.js';
import { getPlatformConfig } from './platforms/index.js';

const config: PlatformConfig = getPlatformConfig('twitch');

console.log(config.name);        // "Twitch"
console.log(config.color);       // 0x9146FF
console.log(config.emoji);       // "🟣"
console.log(config.urlTemplate); // "https://twitch.tv/{username}"

const status = await config.checker('xqc');

interface Command {
  data: SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder | Omit<SlashCommandBuilder, "addSubcommand" | "addSubcommandGroup">;
  execute: (interaction: ChatInputCommandInteraction) => Promise<void>;
  autocomplete?: (interaction: AutocompleteInteraction) => Promise<void>;
}

import type { Command } from './types/discord.js';
import { SlashCommandBuilder } from 'discord.js';

const pingCommand: Command = {
  data: new SlashCommandBuilder()
    .setName('ping')
    .setDescription('Replies with Pong!'),
  
  execute: async (interaction) => {
    await interaction.reply('Pong!');
  },
};

interface StreamerBotClient extends Client {
  commands: Collection<string, Command>;
}

import type { StreamerBotClient } from './types/discord.js';
import { StreamerBot } from './client/StreamerBot.js';

const client: StreamerBotClient = new StreamerBot();

// Register command
client.commands.set('ping', pingCommand);

// Get command
const command = client.commands.get('ping');

interface InteractionData {
  action: string;
  streamerId?: string;
  page?: number;
  platform?: string;
  username?: string;
}

import type { InteractionData } from './types/discord.js';
import { encodeCustomId, decodeCustomId } from './types/discord.js';

const data: InteractionData = {
  action: 'confirm_remove',
  streamerId: 'twitch:xqc',
};

const customId = encodeCustomId(data);
console.log(customId); // JSON string

const decoded = decodeCustomId(customId);
if (decoded) {
  console.log(decoded.action);     // "confirm_remove"
  console.log(decoded.streamerId); // "twitch:xqc"
}

function encodeCustomId(data: InteractionData): string

const customId = encodeCustomId({
  action: 'page_next',
  page: 2,
});

function decodeCustomId(customId: string): InteractionData | null

const data = decodeCustomId(interaction.customId);
if (data) {
  console.log(`Action: ${data.action}`);
}

export const ButtonIds = {
  CONFIRM_REMOVE: "confirm_remove",
  CANCEL: "cancel",
  PAGE_PREV: "page_prev",
  PAGE_NEXT: "page_next",
  WATCH_STREAM: "watch_stream",
} as const;

import { ButtonIds } from './types/discord.js';

const button = new ButtonBuilder()
  .setCustomId(ButtonIds.WATCH_STREAM)
  .setLabel('Watch Now');

export const SelectMenuIds = {
  CHANNEL_SELECT: "channel_select",
  STREAMER_SELECT: "streamer_select",
  HELP_CATEGORY: "help_category",
} as const;

import { SelectMenuIds } from './types/discord.js';

const menu = new StringSelectMenuBuilder()
  .setCustomId(SelectMenuIds.CHANNEL_SELECT)
  .setPlaceholder('Select a channel');

// From types/index.ts
export * from './streamer.js';
export * from './discord.js';

// Import specific types
import type { Platform, LiveStatus, Streamer } from './types/index.js';

// Import all types
import * as Types from './types/index.js';

const platform: Types.Platform = 'twitch';