Types

interface Message {
  content: string;
  authorId: string;
  authorName: string;
  messageId: string;
  serverId: string | null;   // null for a DM
  channelId: string;         // for a DM, this is the dm id
  isDM: boolean;
  dmId: string | null;
  createdAt: Date | null;
  repliedTo: {
    messageId: string;
    authorId: string;
    content: string;
    createdAt: Date | null;
  } | null;
  mentions: MessageMentions;
  mentionsMe: boolean;
  attachments: FileAttachment[];
  poll: MessagePoll | null;
  threadId: string | null;
  threadParentId: string | null;
  postId: string | null;
  forumChannelId: string | null;
  starter: boolean;
  card: MessageCard | null;
  reply(text: string, opts?: SendOptions): Promise<void>;
  channel: { send(text: string, opts?: SendOptions): Promise<void> };
  react(reactionId: string): Promise<void>;
  unreact(reactionId: string): Promise<void>;
  edit(newContent: string): Promise<void>;
  delete(): Promise<void>;
  pin(): Promise<void>;
  unpin(): Promise<void>;
  editCard(card: CardEdit): Promise<void>;
  pinned?: boolean;
  command?: CommandInvocation;
}

interface SendOptions {
  groupId?: string;
  mentions?: MentionTarget[];
  replyTo?: ReplyTarget;
  poll?: PollCreate;
  threadId?: string;
  postId?: string;
  ack?: boolean;
  ackTimeoutMs?: number;
}

interface BotCapabilities {
  wire: number;                // the wire version the session was accepted at
  replay: boolean;             // resume replay is armed for this session
  sendAck: boolean;            // the bot-only send ack is on (wire >= 4)
  sendNonce: boolean;          // the send nonce is echoed on a denial and deduplicated
  reactionOp: boolean;         // reactionUpdate.operation is authoritative
  deleteActor: boolean;        // messageDelete.actorId is carried
  typingRouting: boolean;      // the typing event carries serverId / channelId
  containerParents: boolean;   // container frames and hooks carry kind + parent
  resolveContainer: boolean;   // resolveContainer() exists
  fetchMessage: boolean;       // fetchMessage() exists
  starterReactionAck: boolean; // reactToStarter() is answered with a verdict
  rest: boolean;               // bot REST credentials are enabled server-side
  rateLimitEnforced: boolean;  // opcode rate limiting is enforced, not observe-only
}

type SendFileOptions = SendOptions & { text?: string; signal?: AbortSignal };

interface FileInput {
  name: string;
  bytes: Buffer;
  contentType?: string;
}

interface TypingTarget {
  groupId?: string;
  threadId?: string;
  postId?: string;
}

type ReplyTarget = Pick<Message, 'messageId' | 'authorId' | 'createdAt'>;

type MentionTarget =
  | { userId: string }
  | { roleId: string }
  | 'everyone'
  | 'here';

interface MessageMentions {
  userIds: string[];
  names: string[];
  everyone: boolean;
  here: boolean;
}

interface SystemMessageEvent {
  type: 'member_join' | 'bot_add' | 'thread_created' | 'unknown';
  actorId: string;
  actorName: string;
  serverId: string;
  channelId: string;
  groupId?: string;
  threadId?: string;
}

interface ForumPost {
  postId: string;
  serverId: string;
  forumChannelId: string;
  title: string;
  authorId: string;
  authorName: string;
  createdAt: Date | null;
  lastActiveAt: Date | null;
  replyCount: number;
  tagIds: number[];
  archived: boolean;
  locked: boolean;
  pinned: boolean;
  answered: { messageId: string; at: Date | null; authorId: string } | null;
  starterMessageId: string | null;
  starterContent: string | null;
  following: boolean;
}

interface ForumTag {
  id: number;
  name: string;
  emoji: string;
  moderated: boolean;
}

interface ForumMeta {
  serverId: string;
  forumChannelId: string;
  tags: ForumTag[];
  guidelines: string;
  requireTag: boolean;
  defaultSort: 'activity' | 'created';
  autoArchiveDays: number;
  defaultReaction: string;
  totalPosts: number;
}

type ForumPostStateFieldName = 'archived' | 'locked' | 'pinned' | 'answered' | 'move';

interface Interaction {
  id: string;
  kind: 'button' | 'select' | 'modal';
  customId: string;
  values: string[];
  fields: Record<string, string>;
  parentId: string | null;
  userId: string;
  botId: string;
  messageId: string;
  serverId: string | null;
  channelId: string;
  threadId: string | null;
  postId: string | null;
  createdAt: Date | null;
  ack(): Promise<void>;
  showModal(def: ModalDefinition): Promise<void>;
  ephemeral(reply: EphemeralMessage): Promise<void>;
}

interface Member {
  userId: string;
  username: string;
  status: number;
  createdAt: Date | null;
  icon: string | null;
  subscriptionTier: number | null;
  isBot: boolean;
  role: MemberRole | null;
}

interface MemberSearchResult {
  userId: string;
  username: string;
  displayName: string;
  nickname: string;
  icon: string | null;
  status: number;
  isBot: boolean;
  subscriptionTier: number | null;
  role: MemberRole | null;
  onMobile: boolean;
}

interface MemberRole {
  id: string;
  name: string;
  color: string | null;
  secondColor: string | null;
  admin: boolean;
}

interface Role {
  id: string;
  name: string;
  color: string | null;
  secondColor: string | null;
  position: number | null;
  memberCount: number;
}

interface BanInfo {
  userId: string;
  username: string | null;
  bannedAt: Date | null;
  reason: string;
}

interface MessageLocation {
  serverId: string | null;
  channelId: string;
  groupId?: string;
  authorId: string;
  createdAtMs: number | null;
}

interface ChannelInfo {
  id: string;
  name: string;
  groupId: string;
  type: number;
  order: number;
  lastMessageAt: Date | null;
}

const ChannelType = {
  TEXT: 0,
  VOICE: 1,
  CALENDAR: 2,
  BOARD: 3,
  FORUM: 4,
  TICKET: 5,
} as const;

import { ChannelType, channelTypeName } from '@cloak-software/bot-sdk';

const channels = await client.fetchChannels(serverId);
const voice = channels.filter((c) => c.type === ChannelType.VOICE);

channelTypeName(1); // 'VOICE'
channelTypeName(99); // undefined

interface VoiceConnection {
  serverId: string;
  channelId: string;
  groupId: string;
  token: string;
  url: string;
  selfMuted: boolean;
  selfDeafened: boolean;
  joinedAt: Date;
}

interface VoiceParticipant {
  userId: string;
  channelId: string;
  muted: boolean;
  deafened: boolean;
  serverMuted: boolean;
  serverDeafened: boolean;
  webcam: boolean;
  stream: boolean;
  reconnecting: boolean;
  // Deprecated. P2P was removed from the platform, so both are always false.
  p2pWebcam: boolean;
  p2pStream: boolean;
}

type BotStatus = 'invisible' | 'online' | 'away' | 'busy' | 'dnd';

type VoiceStateFlag = 'muted' | 'deafened' | 'webcam' | 'stream' | 'p2pWebcam' | 'p2pStream';

interface Guild {
  id: string;
}

interface BotUser {
  id: string;
  username: string;
}

type PermissionSet = { effectiveRank: number } & Record<PermissionName, boolean>;