TypeScript Types

import type {
  // User types
  Platform,
  CreateUserConfig,
  SetUserConfig,
  UserData,
  UserInfo,

  // Channel types
  ChannelType,
  CreateChannelConfig,
  ChannelParticipant,
  Channel,

  // Event types
  BroadcastStartEvent,
  BroadcastEndEvent,
  ConnectionChangeEvent,
  ConnectionStatus,
  NewChannelEvent,
  RoomNameUpdateEvent,
  ParticipantAddedEvent,
  ParticipantRemovedEvent,
  AdminAddedEvent,
  AdminRemovedEvent,
  NewSdkUserEvent,
  MessageEvent,
  PlaybackProgressEvent,

  // PTT result types
  StartTalkingResult,
  StartTalkingResultCode,

  // Config types
  TalkerAdminConfig,
  TalkerClientConfig,
  LoggerConfig,

  // Credentials
  CredentialsData,
  WebRTCCredentials,
} from '@talker-network/talker-sdk';

type Platform = 'WEB' | 'ANDROID' | 'IOS';

interface CreateUserConfig {
  name: string;           // Required: Display name
  platform?: Platform;    // Optional: Platform identifier
  fcmToken?: string;      // Optional: Firebase Cloud Messaging token
}

interface SetUserConfig {
  userId: string;         // Required: Existing user ID
  platform?: Platform;    // Optional: Platform identifier
  fcmToken?: string;      // Optional: Firebase Cloud Messaging token
}

interface UserData {
  userId: string;
  name: string;
  userAuthToken: string;  // Pass to TalkerClient
  aUsername: string;      // Pass to TalkerClient
  aPassword: string;      // Pass to TalkerClient
}

interface UserInfo {
  id: string;
  name: string;
  platform: string;
}

type ChannelType = 'group' | 'direct';

interface CreateChannelConfig {
  name: string;              // Required: Channel name
  participants: string[];    // Required: Array of user IDs
  workspaceId: string;       // Required: Workspace ID
  type?: ChannelType;        // Optional: 'group' | 'direct'
}

interface ChannelParticipant {
  id: string;
  name: string;
  isAdmin: boolean;
}

interface Channel {
  channelId: string;
  channelName: string;
  channelType: ChannelType;
  participants: ChannelParticipant[];
}

type ConnectionStatus = 'connected' | 'connecting' | 'disconnected';

interface ConnectionChangeEvent {
  connected: boolean;
  status: ConnectionStatus;
}

interface BroadcastStartEvent {
  channelId: string;
  senderId: string;
  senderName: string;
  messageId?: string;
  timestamp: number;
}

interface BroadcastEndEvent {
  channelId: string;
  senderId: string;
  timestamp: number;
}

interface PlaybackProgressEvent {
  duration: number;  // seconds elapsed
}

interface NewChannelEvent {
  channel: {
    channelId: string;
    channelName: string;
    channelType: ChannelType;
  };
  timestamp: number;
}

interface RoomNameUpdateEvent {
  channelId: string;
  newName: string;
  timestamp: number;
}

interface ParticipantAddedEvent {
  channelId: string;
  userId: string;
  userName: string;
  timestamp: number;
}

interface ParticipantRemovedEvent {
  channelId: string;
  userId: string;
  timestamp: number;
}

interface AdminAddedEvent {
  channelId: string;
  userId: string;
  timestamp: number;
}

interface AdminRemovedEvent {
  channelId: string;
  userId: string;
  timestamp: number;
}

interface NewSdkUserEvent {
  userId: string;
  userName: string;
  timestamp: number;
}

interface MessageEvent {
  message: {
    messageId: string;
    channelId: string;
    senderId: string;
    senderName: string;
    type: string;
    text?: string;
    mediaUrl?: string;
    timestamp: string;
  };
}

type StartTalkingResultCode =
  | 'success'
  | 'already_talking'
  | 'not_connected'
  | 'no_user_id'
  | 'error';

interface StartTalkingResult {
  success: boolean;
  code: StartTalkingResultCode;
  message: string;
}

interface TalkerAdminConfig {
  sdkKey: string;       // Required: SDK key
  baseUrl?: string;     // Optional: API base URL
}

interface TalkerClientConfig {
  userAuthToken: string;    // Required: From backend
  userId: string;           // Required: From backend
  a_username: string;       // Required: From backend
  a_password: string;       // Required: From backend
  baseUrl?: string;         // Optional: API base URL
  socketUrl?: string;       // Optional: Socket.IO URL
  loggerConfig?: LoggerConfig;
}

interface LoggerConfig {
  level?: LogLevel;                    // DEBUG, INFO, WARN, ERROR, OFF
  enableConsole?: boolean;             // Force console output
  customHandler?: (entry: LogEntry) => void;
}

enum LogLevel {
  TRACE = 0,
  DEBUG = 1,
  INFO = 2,
  WARN = 3,
  ERROR = 4,
  OFF = 5
}

interface LogEntry {
  level: LogLevel;
  component: string;
  event: string;
  data?: any;
  timestamp: Date;
}

interface CredentialsData {
  workspaceId: string;
  // Additional credential properties
}

interface WebRTCCredentials {
  username: string;
  credential: string;
  urls: string[];
  ttl: number;
}