discordplace-sync/index.d.ts

SDK officiel pour synchroniser automatiquement les statistiques de votre bot Discord avec DiscordPlace

declare module 'discordplace-sync' {
  import { EventEmitter } from 'events';
  
  interface CommandOption {
    name: string;
    description?: string;
    type: string;
    required?: boolean;
    choices?: Array<{ name: string; value: string | number }>;
    minLength?: number;
    maxLength?: number;
    minValue?: number;
    maxValue?: number;
  }

  interface Command {
    name: string;
    description?: string;
    type: 'slash_command' | 'command';
    options?: CommandOption[];
  }

  interface BotStats {
    guildCount: number;
    userCount?: number;
    shardCount?: number;
    latency?: number;
    uptime?: number;
    channelCount?: number;
    commandCount?: number;
    commands?: Command[];
    isOnline?: boolean;
  }

  interface SyncOptions {
    treatAllAsHybrid?: boolean;
    prefixOnlyCommands?: string[];
    slashOnlyCommands?: string[];
    isAutoSync?: boolean;
  }

  interface DiscordClient {
    user: {
      id: string;
      tag?: string;
      username?: string;
      displayAvatarURL?: (options?: { format?: string; size?: number }) => string;
    };
    guilds: {
      cache: Map<string, any> | { size: number };
    };
    commands?: Map<string, any> | Array<any>;
    slashCommands?: Map<string, any> | Array<any>;
    prefixCommands?: Map<string, any> | Array<any>;
    application?: {
      commands?: {
        cache: Map<string, any>;
        fetch: () => Promise<any>;
      };
    };
    ws?: {
      ping?: number;
    };
    uptime?: number;
    on: (event: string, listener: (...args: any[]) => void) => void;
    once: (event: string, listener: (...args: any[]) => void) => void;
  }

  export class DiscordPlaceSDK extends EventEmitter {
    constructor(options: {
      apiKey: string;
      botId: string;
      endpoint?: string;
      autoSync?: boolean;
      syncInterval?: number;
      timeout?: number;
      retries?: number;
    });
    
    start(): void;
    stop(): void;
    updateStats(stats: BotStats): Promise<any>;
    postStats(stats: BotStats): Promise<any>;
    getStats(period?: string): Promise<any>;
    getApiKeyInfo(): Promise<any>;
    autoCollectStats(client: DiscordClient): Promise<any>;
    syncBotInfo(client: DiscordClient, options?: SyncOptions): Promise<any>;
    checkSyncStatus(): Promise<any>;
    
    on(event: 'start', listener: () => void): this;
    on(event: 'stop', listener: () => void): this;
    on(event: 'success', listener: (data: any) => void): this;
    on(event: 'syncSuccess', listener: (data: any) => void): this;
    on(event: 'forceSyncDetected', listener: (data: any) => void): this;
    on(event: 'forceSyncCompleted', listener: (data: any) => void): this;
    on(event: 'error', listener: (error: Error) => void): this;
    on(event: string, listener: (...args: any[]) => void): this;
    
    emit(event: 'start'): boolean;
    emit(event: 'stop'): boolean;
    emit(event: 'success', data: any): boolean;
    emit(event: 'syncSuccess', data: any): boolean;
    emit(event: 'forceSyncDetected', data: any): boolean;
    emit(event: 'forceSyncCompleted', data: any): boolean;
    emit(event: 'error', error: Error): boolean;
    emit(event: string, ...args: any[]): boolean;
  }

  export class SyncClient extends EventEmitter {
    constructor(apiKey: string, client: DiscordClient);
    
    updateStats(stats: BotStats): Promise<void>;
    start(): void;
    stop(): void;
    
    on(event: 'synced', listener: (stats: BotStats) => void): this;
    on(event: 'error', listener: (error: Error) => void): this;
    on(event: string, listener: (...args: any[]) => void): this;
  }
}