Guild Management

/**
 * Represents a Discord guild (server)
 * @extends AnonymousGuild
 */
class Guild extends AnonymousGuild {
  // Core properties
  readonly id: Snowflake;
  readonly name: string;
  readonly description: string | null;
  readonly ownerId: Snowflake;
  readonly memberCount: number;
  readonly large: boolean;
  readonly premiumTier: GuildPremiumTier;
  readonly premiumSubscriptionCount: number | null;
  readonly available: boolean;
  readonly createdAt: Date;
  
  // Managers
  readonly channels: GuildChannelManager;
  readonly members: GuildMemberManager;
  readonly roles: RoleManager;
  readonly bans: GuildBanManager;
  readonly invites: GuildInviteManager;
  readonly scheduledEvents: GuildScheduledEventManager;
  readonly stickers: GuildStickerManager;
  readonly emojis: GuildEmojiManager;
  readonly commands: GuildApplicationCommandManager;
  readonly autoModerationRules: AutoModerationRuleManager;
  
  // Guild management
  edit(options: GuildEditOptions): Promise<Guild>;
  delete(): Promise<Guild>;
  leave(): Promise<Guild>;
  
  // Member management
  fetchOwner(options?: BaseFetchOptions): Promise<GuildMember>;
  fetchMembers(options?: GuildFetchMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
  
  // Moderation
  fetchBans(options?: GuildFetchBansOptions): Promise<Collection<Snowflake, GuildBan>>;
  fetchBan(user: UserResolvable, options?: BaseFetchOptions): Promise<GuildBan>;
  
  // Utility methods
  fetchPreview(): Promise<GuildPreview>;
  fetchTemplates(): Promise<Collection<string, GuildTemplate>>;
  fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
  fetchAuditLogs(options?: GuildAuditLogsFetchOptions): Promise<GuildAuditLogs>;
  fetchWidget(): Promise<Widget>;
  setMFALevel(level: GuildMFALevel, reason?: string): Promise<Guild>;
  
  // Icon and banner URLs
  iconURL(options?: ImageURLOptions): string | null;
  bannerURL(options?: ImageURLOptions): string | null;
  splashURL(options?: ImageURLOptions): string | null;
  discoverySplashURL(options?: ImageURLOptions): string | null;
}

interface GuildEditOptions {
  name?: string;
  description?: string | null;
  verificationLevel?: GuildVerificationLevel | null;
  explicitContentFilter?: GuildExplicitContentFilter | null;
  defaultMessageNotifications?: GuildDefaultMessageNotifications | null;
  afkChannel?: VoiceChannelResolvable | null;
  systemChannel?: TextChannelResolvable | null;
  afkTimeout?: number;
  icon?: BufferResolvable | Base64Resolvable | null;
  owner?: GuildMemberResolvable;
  banner?: BufferResolvable | Base64Resolvable | null;
  splash?: BufferResolvable | Base64Resolvable | null;
  discoverySplash?: BufferResolvable | Base64Resolvable | null;
  rulesChannel?: TextChannelResolvable | null;
  publicUpdatesChannel?: TextChannelResolvable | null;
  preferredLocale?: Locale | null;
  premiumProgressBarEnabled?: boolean;
  reason?: string;
}

// Edit guild settings
await guild.edit({
  name: 'New Server Name',
  description: 'Updated server description',
  verificationLevel: GuildVerificationLevel.Medium
});

// Fetch all members (requires privileged intent)
const members = await guild.members.fetch();

// Get guild owner
const owner = await guild.fetchOwner();

// Check guild features
if (guild.features.includes(GuildFeature.Community)) {
  console.log('This is a community server');
}

/**
 * Represents a guild member
 * @extends Base
 */
class GuildMember extends Base {
  readonly guild: Guild;
  readonly user: User;
  readonly roles: GuildMemberRoleManager;
  readonly voice: VoiceState;
  readonly permissions: Readonly<PermissionsBitField>;
  readonly permissionsIn: (channel: GuildChannelResolvable) => Readonly<PermissionsBitField>;
  
  // Member properties
  readonly joinedAt: Date | null;
  readonly premiumSince: Date | null;
  readonly nickname: string | null;
  readonly displayName: string;
  readonly displayAvatarURL: (options?: ImageURLOptions) => string;
  readonly communicationDisabledUntil: Date | null;
  readonly flags: Readonly<GuildMemberFlagsBitField>;
  
  // Member management
  edit(options: GuildMemberEditOptions): Promise<GuildMember>;
  kick(reason?: string): Promise<GuildMember>;
  ban(options?: BanOptions): Promise<GuildMember>;
  timeout(timeout: number | null, reason?: string): Promise<GuildMember>;
  
  // Permission checks
  hasPermission(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
  isCommunicationDisabled(): boolean;
  
  // Avatar and display
  avatarURL(options?: ImageURLOptions): string | null;
  setNickname(nickname: string | null, reason?: string): Promise<GuildMember>;
}

interface GuildMemberEditOptions {
  nick?: string | null;
  roles?: Collection<Snowflake, Role> | RoleResolvable[];
  mute?: boolean;
  deaf?: boolean;
  channel?: GuildVoiceChannelResolvable | null;
  communicationDisabledUntil?: DateResolvable | null;
  flags?: GuildMemberFlagsResolvable;
  reason?: string;
}

interface BanOptions {
  deleteMessageSeconds?: number;
  reason?: string;
}

/**
 * Represents a Discord role
 * @extends Base
 */
class Role extends Base {
  readonly guild: Guild;
  readonly id: Snowflake;
  readonly name: string;
  readonly color: number;
  readonly hoist: boolean;
  readonly position: number;
  readonly permissions: Readonly<PermissionsBitField>;
  readonly managed: boolean;
  readonly mentionable: boolean;
  readonly createdAt: Date;
  readonly hexColor: string;
  readonly unicodeEmoji: string | null;
  readonly icon: string | null;
  readonly tags: RoleTags | null;
  readonly flags: Readonly<RoleFlagsBitField>;
  
  // Role management
  edit(options: RoleEditOptions): Promise<Role>;
  delete(reason?: string): Promise<Role>;
  setName(name: string, reason?: string): Promise<Role>;
  setColor(color: ColorResolvable, reason?: string): Promise<Role>;
  setHoist(hoist?: boolean, reason?: string): Promise<Role>;
  setMentionable(mentionable?: boolean, reason?: string): Promise<Role>;
  setPermissions(permissions: PermissionResolvable, reason?: string): Promise<Role>;
  setPosition(position: number, reason?: string): Promise<Role>;
  setIcon(icon: BufferResolvable | Base64Resolvable | EmojiResolvable | null, reason?: string): Promise<Role>;
  setUnicodeEmoji(unicodeEmoji: string | null, reason?: string): Promise<Role>;
  
  // Utility methods
  iconURL(options?: ImageURLOptions): string | null;
  comparePositionTo(role: RoleResolvable): number;
  toString(): string;
}

interface RoleEditOptions {
  name?: string;
  color?: ColorResolvable;
  hoist?: boolean;
  permissions?: PermissionResolvable;
  position?: number;
  mentionable?: boolean;
  icon?: BufferResolvable | Base64Resolvable | EmojiResolvable | null;
  unicodeEmoji?: string | null;
  reason?: string;
}

/**
 * Base class for guild channels
 * @extends BaseChannel
 */
class GuildChannel extends BaseChannel {
  readonly guild: Guild;
  readonly guildId: Snowflake;
  readonly permissionOverwrites: PermissionOverwriteManager;
  readonly viewable: boolean;
  readonly deletable: boolean;
  readonly manageable: boolean;
  readonly position: number;
  readonly parent: CategoryChannel | null;
  readonly parentId: Snowflake | null;
  
  edit(options: GuildChannelEditOptions): Promise<this>;
  delete(reason?: string): Promise<this>;
  setName(name: string, reason?: string): Promise<this>;
  setParent(channel: CategoryChannelResolvable | null, options?: SetParentOptions): Promise<this>;
  setPosition(position: number, options?: SetChannelPositionOptions): Promise<this>;
  
  permissionsFor(memberOrRole: GuildMemberResolvable | RoleResolvable): Readonly<PermissionsBitField> | null;
  lockPermissions(): Promise<this>;
}

/**
 * Text channel in a guild
 * @extends BaseGuildTextChannel
 */
class TextChannel extends BaseGuildTextChannel {
  readonly type: ChannelType.GuildText;
  readonly threads: GuildTextThreadManager;
  
  setTopic(topic: string | null, reason?: string): Promise<this>;
  setNSFW(nsfw?: boolean, reason?: string): Promise<this>;
  setRateLimitPerUser(rateLimitPerUser: number, reason?: string): Promise<this>;
  setDefaultAutoArchiveDuration(defaultAutoArchiveDuration: ThreadAutoArchiveDuration | null, reason?: string): Promise<this>;
}

/**
 * Voice channel in a guild
 * @extends BaseGuildVoiceChannel
 */
class VoiceChannel extends BaseGuildVoiceChannel {
  readonly type: ChannelType.GuildVoice;
  readonly bitrate: number;
  readonly userLimit: number;
  readonly rtcRegion: string | null;
  readonly videoQualityMode: VideoQualityMode | null;
  
  setBitrate(bitrate: number, reason?: string): Promise<this>;
  setUserLimit(userLimit: number, reason?: string): Promise<this>;
  setRTCRegion(rtcRegion: string | null, reason?: string): Promise<this>;
  setVideoQualityMode(videoQualityMode: VideoQualityMode | null, reason?: string): Promise<this>;
}

/**
 * Category channel for organizing other channels
 * @extends GuildChannel
 */
class CategoryChannel extends GuildChannel {
  readonly type: ChannelType.GuildCategory;
  readonly children: CategoryChildChannel[];
}

/**
 * Forum channel for threaded discussions
 * @extends GuildChannel
 */
class ForumChannel extends GuildChannel {
  readonly type: ChannelType.GuildForum;
  readonly threads: GuildForumThreadManager;
  readonly availableTags: GuildForumTag[];
  readonly defaultReactionEmoji: DefaultReactionEmoji | null;
  readonly defaultThreadRateLimitPerUser: number | null;
  readonly rateLimitPerUser: number;
  readonly defaultSortOrder: SortOrderType | null;
  readonly defaultForumLayout: ForumLayoutType;
  
  setAvailableTags(availableTags: GuildForumTagData[], reason?: string): Promise<this>;
  setTopic(topic: string | null, reason?: string): Promise<this>;
  setDefaultReactionEmoji(defaultReactionEmoji: DefaultReactionEmoji | null, reason?: string): Promise<this>;
}

/**
 * Represents permission overwrites for a channel
 */
class PermissionOverwrites extends Base {
  readonly id: Snowflake;
  readonly type: OverwriteType;
  readonly deny: Readonly<PermissionsBitField>;
  readonly allow: Readonly<PermissionsBitField>;
  
  edit(options: PermissionOverwriteOptions, reason?: string): Promise<PermissionOverwrites>;
  delete(reason?: string): Promise<PermissionOverwrites>;
}

/**
 * BitField representing Discord permissions
 */
class PermissionsBitField extends BitField<PermissionsString> {
  static Flags: typeof PermissionFlagsBits;
  static All: bigint;
  static Default: bigint;
  static StageModerator: bigint;
  
  any(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
  has(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
  missing(permissions: PermissionResolvable, checkAdmin?: boolean): PermissionsString[];
  serialize(checkAdmin?: boolean): Record<PermissionsString, boolean>;
  toArray(): PermissionsString[];
}

const PermissionFlagsBits: {
  CreateInstantInvite: 1n << 0n;
  KickMembers: 1n << 1n;
  BanMembers: 1n << 2n;
  Administrator: 1n << 3n;
  ManageChannels: 1n << 4n;
  ManageGuild: 1n << 5n;
  AddReactions: 1n << 6n;
  ViewAuditLog: 1n << 7n;
  PrioritySpeaker: 1n << 8n;
  Stream: 1n << 9n;
  ViewChannel: 1n << 10n;
  SendMessages: 1n << 11n;
  SendTTSMessages: 1n << 12n;
  ManageMessages: 1n << 13n;
  EmbedLinks: 1n << 14n;
  AttachFiles: 1n << 15n;
  ReadMessageHistory: 1n << 16n;
  MentionEveryone: 1n << 17n;
  UseExternalEmojis: 1n << 18n;
  ViewGuildInsights: 1n << 19n;
  Connect: 1n << 20n;
  Speak: 1n << 21n;
  MuteMembers: 1n << 22n;
  DeafenMembers: 1n << 23n;
  MoveMembers: 1n << 24n;
  UseVAD: 1n << 25n;
  ChangeNickname: 1n << 26n;
  ManageNicknames: 1n << 27n;
  ManageRoles: 1n << 28n;
  ManageWebhooks: 1n << 29n;
  ManageGuildExpressions: 1n << 30n;
  UseApplicationCommands: 1n << 31n;
  RequestToSpeak: 1n << 32n;
  ManageEvents: 1n << 33n;
  ManageThreads: 1n << 34n;
  CreatePublicThreads: 1n << 35n;
  CreatePrivateThreads: 1n << 36n;
  UseExternalStickers: 1n << 37n;
  SendMessagesInThreads: 1n << 38n;
  UseEmbeddedActivities: 1n << 39n;
  ModerateMembers: 1n << 40n;
  ViewCreatorMonetizationAnalytics: 1n << 41n;
  UseSoundboard: 1n << 42n;
  UseExternalSounds: 1n << 45n;
  SendVoiceMessages: 1n << 46n;
};

/**
 * Manages guild channels
 */
class GuildChannelManager extends CachedManager<Snowflake, GuildChannel, GuildChannelResolvable> {
  create(options: GuildChannelCreateOptions): Promise<GuildChannel>;
  edit(channel: GuildChannelResolvable, options: GuildChannelEditOptions): Promise<GuildChannel>;
  delete(channel: GuildChannelResolvable, reason?: string): Promise<void>;
  setPosition(channel: GuildChannelResolvable, position: number, options?: SetChannelPositionOptions): Promise<GuildChannel>;
  setPositions(channelPositions: readonly ChannelPosition[]): Promise<Guild>;
  
  fetchActiveThreads(cache?: boolean): Promise<FetchedThreads>;
}

/**
 * Manages guild members
 */
class GuildMemberManager extends CachedManager<Snowflake, GuildMember, GuildMemberResolvable> {
  add(user: UserResolvable, options: AddGuildMemberOptions): Promise<GuildMember>;
  ban(user: UserResolvable, options?: BanOptions): Promise<GuildMember | User | Snowflake>;
  edit(user: UserResolvable, options: GuildMemberEditOptions): Promise<GuildMember>;
  kick(user: UserResolvable, reason?: string): Promise<GuildMember | User | Snowflake>;
  list(options?: GuildListMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
  prune(options?: GuildPruneMembersOptions): Promise<number | null>;
  search(options: GuildSearchMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
  unban(user: UserResolvable, reason?: string): Promise<User | null>;
}

/**
 * Manages guild roles
 */
class RoleManager extends CachedManager<Snowflake, Role, RoleResolvable> {
  create(options?: CreateRoleOptions): Promise<Role>;
  edit(role: RoleResolvable, options: RoleEditOptions): Promise<Role>;
  delete(role: RoleResolvable, reason?: string): Promise<void>;
  setPosition(role: RoleResolvable, position: number, reason?: string): Promise<Role>;
  setPositions(rolePositions: readonly RolePosition[]): Promise<Guild>;
  
  readonly everyone: Role;
  readonly premiumSubscriberRole: Role | null;
  readonly botRoleFor: (user: UserResolvable) => Role | null;
  comparePositions(role1: RoleResolvable, role2: RoleResolvable): number;
}

// Create a new role
const moderatorRole = await guild.roles.create({
  name: 'Moderator',
  color: Colors.Blue,
  permissions: [PermissionFlagsBits.KickMembers, PermissionFlagsBits.ManageMessages],
  hoist: true,
  mentionable: true,
  reason: 'Created moderator role'
});

// Add role to member
const member = await guild.members.fetch('123456789012345678');
await member.roles.add(moderatorRole, 'Promoted to moderator');

// Create text channel with permissions
const channel = await guild.channels.create({
  name: 'staff-only',
  type: ChannelType.GuildText,
  permissionOverwrites: [
    {
      id: guild.roles.everyone.id,
      deny: [PermissionFlagsBits.ViewChannel]
    },
    {
      id: moderatorRole.id,
      allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages]
    }
  ]
});

// Ban a member
await guild.members.ban('123456789012345678', {
  deleteMessageSeconds: 7 * 24 * 60 * 60, // 7 days
  reason: 'Violating server rules'
});

// Check member permissions
const memberPermissions = member.permissions;
if (memberPermissions.has(PermissionFlagsBits.Administrator)) {
  console.log('Member has administrator permissions');
}

// Check channel-specific permissions
const channelPermissions = member.permissionsIn(channel);
if (channelPermissions.has(PermissionFlagsBits.SendMessages)) {
  console.log('Member can send messages in this channel');
}