yuzuha 0.2.0 → 0.3.0

package/src/{scripting → functions}/builtins/canvas.ts

@@ -3,8 +3,8 @@ import type { CanvasAvatarOptions, CanvasBadgeItem, CanvasBadgesOptions, CanvasC
   CanvasImageOptions, CanvasLineOptions, CanvasProgressOptions, CanvasRectOptions, CanvasTextOptions } from '../../domain/canvas.js';
 import type { CanvasBuilder, CanvasSendOptions } from '../../services/canvas.js';
 import { YuzuhaError } from '../../shared/errors.js';
-import { canvasExecution } from '../canvas-execution.js';
-import type { FunctionCall } from '../types.js';
+import { canvasExecution } from '../runtime/canvas-execution.js';
+import type { FunctionCall } from '../runtime/types.js';
 import { defineFunctions } from './definition.js';
 
 function requiredId(value: string): string {

package/src/{scripting → functions}/builtins/context.ts

@@ -1,4 +1,4 @@
-import type { FunctionCall } from '../types.js';
+import type { FunctionCall } from '../runtime/types.js';
 import { index } from './arguments.js';
 import { defineFunctions } from './definition.js';
 

package/src/{scripting → functions}/builtins/definition.ts

@@ -1,4 +1,4 @@
-import type { FunctionCall, FunctionDefinition } from '../types.js';
+import type { FunctionCall, FunctionDefinition } from '../runtime/types.js';
 
 type RegisterBuiltin = (
   name: string, category: string, minArgs: number, maxArgs: number,

package/src/{scripting → functions}/builtins/embeds.ts

@@ -1,7 +1,7 @@
 import type { Embed, EmbedField } from '../../domain/messages.js';
 import { YuzuhaError } from '../../errors.js';
 import { httpURL, isoTimestamp, mergeEmbedParts, normalizeEmbed, normalizeFields, parseColor, validateEmbed } from '../../domain/embeds.js';
-import { truthy } from '../values.js';
+import { truthy } from '../runtime/values.js';
 import { defineFunctions } from './definition.js';
 
 export { validateEmbed } from '../../domain/embeds.js';

package/src/{scripting → functions}/builtins/flow.ts

@@ -1,7 +1,7 @@
 import { GuardError, PartialModerationError, ScriptError, StopExecution, YuzuhaError } from '../../errors.js';
-import { truthy } from '../values.js';
+import { truthy } from '../runtime/values.js';
 import { defineFunctions } from './definition.js';
-import { LoopControl } from '../control-flow.js';
+import { LoopControl } from '../runtime/control-flow.js';
 
 export const flowFunctions = defineFunctions(fn => {
   fn('let', 'flow', 2, 2, '[nome;valor]', 'Define variável local sem produzir texto.', async c => {

package/src/{scripting → functions}/builtins/guards.ts

@@ -1,5 +1,5 @@
 import { GuardError } from '../../errors.js';
-import { truthy } from '../values.js';
+import { truthy } from '../runtime/values.js';
 import { defineFunctions } from './definition.js';
 
 export const guardFunctions = defineFunctions(fn => {

package/src/{scripting → functions}/builtins/http.ts

@@ -1,5 +1,5 @@
-import { text } from '../values.js';
-import { loopFrame, setLoopFrame, LoopControl } from '../control-flow.js';
+import { text } from '../runtime/values.js';
+import { loopFrame, setLoopFrame, LoopControl } from '../runtime/control-flow.js';
 import { YuzuhaError } from '../../errors.js';
 import { defineFunctions } from './definition.js';
 

package/src/{scripting → functions}/builtins/index.ts

@@ -1,5 +1,5 @@
-import type { Runtime } from '../runtime.js';
-import type { FunctionDefinition } from '../types.js';
+import type { Runtime } from '../runtime/runtime.js';
+import type { FunctionDefinition } from '../runtime/types.js';
 import { channelFunctions } from './native-channels.js';
 import { collectorFunctions } from './native-collectors.js';
 import { expressionFunctions } from './native-expressions.js';

package/src/{scripting → functions}/builtins/language/array-callbacks.ts

@@ -1,6 +1,6 @@
 import { YuzuhaError } from '../../../errors.js';
-import type { FunctionCall } from '../../types.js';
-import { text, truthy } from '../../values.js';
+import type { FunctionCall } from '../../runtime/types.js';
+import { text, truthy } from '../../runtime/values.js';
 import { defineFunctions } from '../definition.js';
 import { requireArray } from './common.js';
 import { withLoopState } from './loops.js';

package/src/{scripting → functions}/builtins/language/arrays.ts

@@ -1,6 +1,6 @@
 import { YuzuhaError } from '../../../errors.js';
 import { toJson } from '../arguments.js';
-import { text } from '../../values.js';
+import { text } from '../../runtime/values.js';
 import { defineFunctions } from '../definition.js';
 import { deepEqual, integer, jsonClone, requireArray, typedScalar } from './common.js';
 

package/src/{scripting → functions}/builtins/language/index.ts

@@ -1,4 +1,4 @@
-import type { FunctionDefinition } from '../../types.js';
+import type { FunctionDefinition } from '../../runtime/types.js';
 import { arrayFunctions } from './arrays.js';
 import { arrayCallbackFunctions } from './array-callbacks.js';
 import { loopFunctions } from './loops.js';

package/src/{scripting → functions}/builtins/language/loops.ts

@@ -1,9 +1,9 @@
 import { YuzuhaError } from '../../../errors.js';
-import { text } from '../../values.js';
-import { truthy } from '../../values.js';
-import { loopFrame, setLoopFrame, LoopControl } from '../../control-flow.js';
+import { text } from '../../runtime/values.js';
+import { truthy } from '../../runtime/values.js';
+import { loopFrame, setLoopFrame, LoopControl } from '../../runtime/control-flow.js';
 import { defineFunctions } from '../definition.js';
-import type { FunctionCall } from '../../types.js';
+import type { FunctionCall } from '../../runtime/types.js';
 import { integer, requireArray } from './common.js';
 import { LOOP_ACCUMULATOR_KEY, LOOP_INDEX_KEY, LOOP_MAX, LOOP_VALUE_KEY } from './state.js';
 

package/src/{scripting → functions}/builtins/language/regex.ts

@@ -1,4 +1,4 @@
-import { runRegex } from '../../regex.js';
+import { runRegex } from '../../runtime/regex.js';
 import { defineFunctions } from '../definition.js';
 import { integer } from './common.js';
 

package/src/{scripting → functions}/builtins/moderation.ts

@@ -1,5 +1,5 @@
 import { parseDuration } from '../../domain/values.js';
-import type { FunctionCall } from '../types.js';
+import type { FunctionCall } from '../runtime/types.js';
 import { finite } from './arguments.js';
 import { defineFunctions } from './definition.js';
 import { YuzuhaError } from '../../shared/errors.js';

package/src/{scripting → functions}/builtins/native-channels.ts

@@ -1,7 +1,7 @@
 import { YuzuhaError } from '../../errors.js';
 import { defineFunctions } from './definition.js';
 import { integer } from './language/common.js';
-import type { FunctionCall } from '../types.js';
+import type { FunctionCall } from '../runtime/types.js';
 import { GuardError } from '../../shared/errors.js';
 
 const channelTypes: Record<string, number> = {

package/src/{scripting → functions}/builtins/native-roles.ts

@@ -1,6 +1,6 @@
 import { YuzuhaError } from '../../errors.js';
 import type { RoleInfo } from '../../ports/resources/roles.js';
-import type { FunctionCall } from '../types.js';
+import type { FunctionCall } from '../runtime/types.js';
 import { defineFunctions } from './definition.js';
 import { integer } from './language/common.js';
 

package/src/{scripting → functions}/builtins/native-users.ts

@@ -1,5 +1,5 @@
 import type { ActivityType, PresenceStatus } from '../../ports/resources/common.js';
-import type { FunctionCall } from '../types.js';
+import type { FunctionCall } from '../runtime/types.js';
 import { GuardError, YuzuhaError } from '../../errors.js';
 import { defineFunctions } from './definition.js';
 import { userID } from '../../domain/values.js';

package/src/{scripting → functions}/builtins/payload.ts

@@ -2,8 +2,8 @@ import type { AllowedMentionsPolicy, Embed, MentionParse, Payload } from '../../
 import { assertEmbedCount, normalizeEmbed } from '../../domain/embeds.js';
 import { YuzuhaError } from '../../errors.js';
 import { AuthorizationService } from '../../services/authorization.js';
-import type { FunctionCall } from '../types.js';
-import { text } from '../values.js';
+import type { FunctionCall } from '../runtime/types.js';
+import { text } from '../runtime/values.js';
 import { defineFunctions } from './definition.js';
 
 const MESSAGE_KEYS = new Set(['content', 'embeds', 'tts', 'stickerIds', 'flags', 'allowedMentions']);

package/src/{scripting → functions}/builtins/resource-extras.ts

@@ -3,7 +3,7 @@ import { YuzuhaError } from '../../errors.js';
 import type { AttachmentSpec, BinaryAttachmentSpec } from '../../ports/resources/common.js';
 import type { GuildEditInput } from '../../ports/resources/users.js';
 import type { ThreadEditInput } from '../../ports/resources/threads.js';
-import type { FunctionCall } from '../types.js';
+import type { FunctionCall } from '../runtime/types.js';
 import { defineFunctions } from './definition.js';
 import { messageSearchInput } from '../../domain/message-query.js';
 

package/src/{scripting → functions}/builtins/values.ts

@@ -1,6 +1,6 @@
 import { randomInt } from 'node:crypto';
 import { YuzuhaError } from '../../errors.js';
-import { truthy } from '../values.js';
+import { truthy } from '../runtime/values.js';
 import { finite } from './arguments.js';
 import { defineFunctions } from './definition.js';
 

package/src/{scripting → functions/runtime}/canvas-execution.ts

@@ -1,4 +1,4 @@
-import type { CanvasBuilder } from '../services/canvas.js';
+import type { CanvasBuilder } from '../../services/canvas.js';
 import type { FunctionCall } from './types.js';
 
 export interface CanvasExecutionState {

package/src/{scripting → functions/runtime}/evaluator.ts

@@ -1,6 +1,6 @@
 import { performance } from 'node:perf_hooks';
-import type { CommandContext } from '../commands/context.js';
-import { GuardError, PartialModerationError, ScriptError, StopExecution, YuzuhaError } from '../errors.js';
+import type { CommandContext } from '../../commands/context.js';
+import { GuardError, PartialModerationError, ScriptError, StopExecution, YuzuhaError } from '../../errors.js';
 import type { CallNode, Node, Program } from './ast.js';
 import type { FunctionRegistry } from './registry.js';
 import type { FunctionCall, Limits } from './types.js';

package/src/{scripting → functions/runtime}/limits.ts

@@ -1,4 +1,4 @@
-import { YuzuhaError } from '../errors.js';
+import { YuzuhaError } from '../../errors.js';
 import type { Limits } from './types.js';
 
 export const defaultLimits: Readonly<Limits> = Object.freeze({

package/src/{scripting → functions/runtime}/parser.ts

@@ -1,4 +1,4 @@
-import { ScriptError } from '../errors.js';
+import { ScriptError } from '../../errors.js';
 import type { Node, Program } from './ast.js';
 
 function nameStart(code: number): boolean {

package/src/{scripting → functions/runtime}/regex.ts

@@ -1,5 +1,5 @@
 import { Worker } from 'node:worker_threads';
-import { YuzuhaError } from '../errors.js';
+import { YuzuhaError } from '../../errors.js';
 
 export interface RegexInput {
   operation: 'test' | 'match' | 'replace';

package/src/{scripting → functions/runtime}/registry.ts

@@ -1,4 +1,4 @@
-import { ScriptError, YuzuhaError } from '../errors.js';
+import { ScriptError, YuzuhaError } from '../../errors.js';
 import type { CallNode, Node, Program } from './ast.js';
 import type { FunctionDefinition } from './types.js';
 

package/src/{scripting → functions/runtime}/runtime.ts

@@ -1,10 +1,11 @@
-import type { CommandContext } from '../commands/context.js';
+import type { CommandContext } from '../../commands/context.js';
 import type { Program } from './ast.js';
 import { Evaluator } from './evaluator.js';
 import { defaultLimits, resolveLimits } from './limits.js';
 import { parse } from './parser.js';
 import { FunctionRegistry } from './registry.js';
 import type { FunctionDefinition, Limits } from './types.js';
+import { text } from './values.js';
 
 export class Runtime {
   private readonly registry = new FunctionRegistry();
@@ -26,6 +27,10 @@ export class Runtime {
 
   functions(): FunctionDefinition[] { return this.registry.functions(); }
 
+  fork(): Runtime { return new Runtime(this.limits).registerAll(this.functions()); }
+
+  text(value: unknown): string { return text(value); }
+
   compile(source: string, file?: string): Program {
     const program = parse(source, file);
     this.registry.validate(program);

package/src/{scripting → functions/runtime}/types.ts

@@ -1,4 +1,4 @@
-import type { CommandContext } from '../commands/context.js';
+import type { CommandContext } from '../../commands/context.js';
 
 export interface FunctionDefinition {
   name: string;

package/src/functions.ts

@@ -1,16 +1,36 @@
 import type { Command } from './context.js';
+import { Runtime } from './functions/runtime/runtime.js';
+import { defaultLimits } from './functions/runtime/limits.js';
+import { registerBuiltins } from './functions/builtins/index.js';
+import type { FunctionDefinition, Limits } from './functions/runtime/types.js';
+import type { ScriptEngine } from './ports/script-engine.js';
 
-export { Runtime, defaultLimits, text, truthy } from './runtime.js';
-export type { FunctionCall, FunctionDefinition, Limits } from './runtime.js';
-export { parse } from './parser.js';
-export type { Program, Node, CallNode, TextNode } from './parser.js';
-export { builtinFunctions, registerBuiltins } from './scripting/builtins/index.js';
-export { validateEmbed } from './scripting/builtins/embeds.js';
+export { Runtime } from './functions/runtime/runtime.js';
+export { defaultLimits } from './functions/runtime/limits.js';
+export { text, truthy } from './functions/runtime/values.js';
+export type { FunctionCall, FunctionDefinition, Limits } from './functions/runtime/types.js';
+export { parse } from './functions/runtime/parser.js';
+export type { Program, Node, CallNode, TextNode } from './functions/runtime/ast.js';
+export { builtinFunctions, registerBuiltins } from './functions/builtins/index.js';
+export { validateEmbed } from './functions/builtins/embeds.js';
+export type { ScriptEngine, ScriptFunctionDefinition, ScriptLimits } from './ports/script-engine.js';
 
 /**
- * Marca um comando escrito em function mode. O runtime de funções é ativado
- * automaticamente ao registrar um comando com `code`.
+ * Marca um comando escrito em function mode. O bot precisa de um engine;
+ * veja `functions()`.
  */
 export function script(command: Command): Command {
   return command;
 }
+
+export interface FunctionsOptions {
+  limits?: Partial<Limits>;
+  functions?: FunctionDefinition[];
+}
+
+/** Cria o motor de function mode com os builtins registrados. Use `engine: functions()` no bot. */
+export function functions(options: FunctionsOptions = {}): ScriptEngine {
+  const runtime = new Runtime({ ...defaultLimits, ...options.limits });
+  if (options.functions?.length) runtime.registerAll(options.functions);
+  return registerBuiltins(runtime);
+}

package/src/index.ts

@@ -17,6 +17,7 @@ export type { EventContextOptions } from './commands/event-context.js';
 export type { ScriptEventDefinition } from './framework/script-events.js';
 export type { ScriptEventData, ScriptEventName } from './domain/events.js';
 export type { NativeAccess } from './ports/native.js';
+export type { ScriptEngine, ScriptFunctionDefinition, ScriptLimits } from './ports/script-engine.js';
 export type { NativeVoice, FluxerVoiceConnection, FluxerVoiceDriver } from './ports/voice.js';
 export type { Resources } from './ports/resources.js';
 export type {
@@ -28,12 +29,18 @@ export type {
   ChannelInfo, ChannelCreateInput, ChannelEditInput, ChannelOverwriteInput, ChannelsResources,
 } from './ports/resources/channels.js';
 export type { AttachmentInfo, MessageInfo, MessagesResources, MessageCursor, MessageSearchInput, MessageSearchPage,
-  PinnedMessagesInput, PinnedMessagesPage, ReactionUsersPage } from './ports/resources/messages.js';
-export type { AwaitMessageInput, CollectedMessageInfo, CollectorsResources, ReactionVote } from './ports/resources/collectors.js';
+  PinnedMessagesInput, PinnedMessagesPage, ReactionUsersPage,
+  BulkFetchRequest, BulkFetchInput, BulkFetchRawChannel } from './ports/resources/messages.js';
+export type { AwaitMessageInput, CollectedMessageInfo, CollectMessagesInput, CollectReactionsInput, CollectorsResources, ReactionVote } from './ports/resources/collectors.js';
 export type { WebhookInfo, WebhookSendInput, WebhooksResources } from './ports/resources/webhooks.js';
 export type { EmojiInfo, EmojiCreateInput, EmojiBulkResult, StickerInfo, StickerCreateInput, StickerEditInput, ExpressionsResources } from './ports/resources/expressions.js';
 export type { ThreadInfo, ThreadMemberInfo, ThreadMemberDetails, ThreadCreateInput, ForumPostInput, ThreadsResources, ThreadEditInput, ThreadSearchInput, ThreadSearchPage, ArchivedThreadsInput, ThreadListPage } from './ports/resources/threads.js';
 export type { InviteInfo, InviteCreateInput, InvitesResources } from './ports/resources/invites.js';
+export type { GatewayMembersRequest, ChannelCountsRequest, ForumUnreadsRequest, ThreadSubscriptionInput, GatewayResources } from './ports/resources/gateway.js';
+export type { InstanceEndpointsInfo, InstanceFeaturesInfo, InstanceServicesInfo, InstanceInfo, GatewayInfo, ApplicationInfo,
+  EmojiMetadataInfo, StickerMetadataInfo, EmojiReference, InstanceResources } from './ports/resources/instance.js';
+export type { SudoVerification, SelfGuildInfo, SelfResources } from './ports/resources/self.js';
+export type { CacheLimitsInfo, CacheStatsInfo, MessageSweepInput, MemberSweepInput, CacheResources } from './ports/resources/cache.js';
 export type { AttachmentSpec, BinaryAttachmentSpec, PresenceStatus, ActivityType, ActivityInfo } from './ports/resources/common.js';
 export { NativeModeration } from './services/native-moderation.js';
 export type { NativeModerationOptions, NativeBanOptions, NativeTimeoutOptions, NativeMoveOptions, NativeVoiceOptions, ModerationTarget } from './services/native-moderation.js';

package/src/infrastructure/canvas/napi.ts

@@ -0,0 +1,17 @@
+import { YuzuhaError } from '../../shared/errors.js';
+
+export function canvasDependency(): YuzuhaError {
+  return new YuzuhaError('CANVAS_DEPENDENCY', 'Instale @napi-rs/canvas@^1.0.13 para renderizar imagens com yuzuha/canvas.');
+}
+
+let loaded: typeof import('@napi-rs/canvas') | undefined;
+try {
+  const module = await import('@napi-rs/canvas') as unknown as Record<string, unknown>;
+  loaded = (module.createCanvas ? module : module.default) as typeof import('@napi-rs/canvas');
+} catch (cause) {
+  const code = (cause as NodeJS.ErrnoException)?.code;
+  const message = cause instanceof Error ? cause.message : String(cause);
+  if (code !== 'ERR_MODULE_NOT_FOUND' || !message.includes('@napi-rs/canvas')) throw cause;
+}
+
+export const napi = loaded;

package/src/infrastructure/fluxer/resources/cache.ts

@@ -0,0 +1,69 @@
+import type { Client, GuildChannel } from '@fluxerjs/core';
+import { YuzuhaError } from '../../../errors.js';
+import type { CacheResources } from '../../../ports/resources/cache.js';
+import { toMessageInfo } from './messages.js';
+import { toGuildInfo, toMemberInfo, toUserInfo } from './users.js';
+import { toChannelInfo } from './channels.js';
+
+function bounded(value: number): number | null {
+  return Number.isFinite(value) ? value : null;
+}
+
+export function createCacheResources(client: Client): CacheResources {
+  return {
+    async stats() {
+      const sizes = client.cache.stats();
+      const messages = client._messageCacheStats();
+      const limits = client.cache.limits;
+      return {
+        ...sizes,
+        messages: messages.messages,
+        messageChannels: messages.channels,
+        limits: {
+          guilds: bounded(limits.guilds),
+          channels: bounded(limits.channels),
+          users: bounded(limits.users),
+          members: bounded(limits.members),
+          messages: limits.messages === false ? false : bounded(limits.messages),
+          roles: bounded(limits.roles),
+          emojis: bounded(limits.emojis),
+          stickers: bounded(limits.stickers),
+          cascading: client.cache.cascading,
+        },
+      };
+    },
+    async sweepMessages(input = {}) {
+      const { channelID, maxAgeMs, keep } = input;
+      if (maxAgeMs !== undefined && (!Number.isSafeInteger(maxAgeMs) || maxAgeMs < 0)) {
+        throw new YuzuhaError('SWEEP_AGE', 'maxAgeMs deve ser um inteiro não negativo.');
+      }
+      const cutoff = maxAgeMs === undefined ? null : Date.now() - maxAgeMs;
+      return client.sweepMessages((message, channelId) => {
+        if (cutoff !== null && message.createdAt.getTime() >= cutoff) return false;
+        return keep ? !keep(toMessageInfo(message), channelId) : true;
+      }, channelID);
+    },
+    async sweepMembers(input = {}) {
+      const { guildID, keep } = input;
+      return client.sweepMembers((member, guildId) => {
+        if (guildID !== undefined && guildId !== guildID) return false;
+        return keep ? !keep(toMemberInfo(member), guildId) : true;
+      });
+    },
+    async sweepUsers(input = {}) {
+      return client.cache.sweepUsers((user, id) => (input.keep ? !input.keep(toUserInfo(user), id) : true));
+    },
+    async sweepChannels(input = {}) {
+      return client.cache.sweepChannels((channel, id) => (input.keep ? !input.keep(toChannelInfo(channel as GuildChannel), id) : true));
+    },
+    async sweepGuilds(input = {}) {
+      return client.cache.sweepGuilds((guild, id) => (input.keep ? !input.keep(toGuildInfo(guild), id) : true));
+    },
+    async cascadeChannel(channelID): Promise<void> {
+      client.cache.cascadeChannel(await client.channels.fetch(channelID));
+    },
+    async cascadeGuild(guildID): Promise<void> {
+      client.cache.cascadeGuild(await client.guilds.resolve(guildID));
+    },
+  };
+}

package/src/infrastructure/fluxer/resources/channels.ts

@@ -1,5 +1,5 @@
-import { OverwriteType } from '@fluxerjs/core';
-import type { ChannelEditOptions, ChannelType, Client, GuildChannel, PermissionResolvable } from '@fluxerjs/core';
+import { OverwriteType, ForumLayout } from '@fluxerjs/core';
+import type { ChannelEditOptions, ChannelType, Client, DMChannel, GuildChannel, PermissionResolvable } from '@fluxerjs/core';
 import type { ChannelCreateInput, ChannelEditInput, ChannelInfo, ChannelOverwriteInput, ChannelsResources } from '../../../ports/resources/channels.js';
 import { YuzuhaError } from '../../../errors.js';
 
@@ -12,7 +12,7 @@ type ChannelExtras = {
   contentWarningText?: string | null;
 };
 
-function toChannelInfo(channel: GuildChannel): ChannelInfo {
+export function toChannelInfo(channel: GuildChannel): ChannelInfo {
   const extras = channel as GuildChannel & ChannelExtras;
   return {
     id: channel.id,
@@ -36,6 +36,12 @@ async function guildChannel(client: Client, channelID: string): Promise<GuildCha
   return channel;
 }
 
+async function dmChannel(client: Client, channelID: string): Promise<DMChannel> {
+  const channel = await client.channels.fetch(channelID);
+  if (!channel.isDM()) throw new YuzuhaError('CHANNEL_DM', 'Esta operação exige um canal de DM.');
+  return channel;
+}
+
 function validateExtras(input: ChannelEditInput): void {
   if (input.url !== undefined && input.url !== null) {
     let url: URL;
@@ -73,8 +79,22 @@ async function overwriteKind(client: Client, channel: GuildChannel, targetID: st
 export function createChannelsResources(client: Client): ChannelsResources {
   return {
     async get(channelID): Promise<ChannelInfo> {
+      const channel = await client.channels.fetch(channelID);
+      if (channel.isDM()) {
+        return { id: channel.id, name: channel.name ?? '', type: Number(channel.type), guildID: null,
+          parentID: null, position: 0, topic: null, slowmode: 0, nsfw: false,
+          recipientIDs: channel.recipients.map(user => user.id), ownerID: channel.ownerId };
+      }
       return toChannelInfo(await guildChannel(client, channelID));
     },
+    async addRecipient(channelID, userID): Promise<void> {
+      const channel = await dmChannel(client, channelID);
+      await channel.addRecipient(userID);
+    },
+    async removeRecipient(channelID, userID, options): Promise<void> {
+      const channel = await dmChannel(client, channelID);
+      await channel.removeRecipient(userID, options?.silent === undefined ? undefined : { silent: options.silent });
+    },
     async list(guildID, limit?): Promise<ChannelInfo[]> {
       const guild = await client.guilds.resolve(guildID);
       const channels = [...await guild.fetchChannels()]
@@ -124,6 +144,19 @@ export function createChannelsResources(client: Client): ChannelsResources {
       if (reason === undefined) await channel.edit({ rateLimitPerUser: seconds });
       else await channel.edit({ rateLimitPerUser: seconds, reason });
     },
+    async slowmode(channelID): Promise<number> {
+      const channel = await guildChannel(client, channelID);
+      return (await channel.fetchSlowmode()).rateLimitPerUser ?? 0;
+    },
+    async sendTyping(channelID): Promise<void> {
+      const channel = await guildChannel(client, channelID);
+      if (!channel.isTextBased()) throw new YuzuhaError('CHANNEL_TEXT', 'Canal sem suporte a mensagens.');
+      await channel.sendTyping();
+    },
+    async rtcRegions(channelID) {
+      const channel = await guildChannel(client, channelID);
+      return (await channel.fetchRtcRegions()).map(region => ({ id: region.id, name: region.name, emoji: region.emoji }));
+    },
     async overwrite(channelID, targetID, input: ChannelOverwriteInput): Promise<void> {
       const channel = await guildChannel(client, channelID);
       await channel.permissionOverwrites.edit(targetID, {
@@ -138,6 +171,21 @@ export function createChannelsResources(client: Client): ChannelsResources {
       const member = await guild.fetchMember(userID);
       return member.permissionsIn(channel).toJSON();
     },
+    async editThreadDefaults(channelID, input): Promise<void> {
+      const channel = await guildChannel(client, channelID);
+      const edit = (channel as { editThreadDefaults?: unknown }).editThreadDefaults;
+      if (typeof edit !== 'function') throw new YuzuhaError('CHANNEL_THREAD', 'O canal não suporta padrões de thread.');
+      const { slowmode, autoArchiveDuration, reason } = input;
+      await (edit as (options: Record<string, unknown>) => Promise<unknown>).call(channel, {
+        autoArchiveDuration: autoArchiveDuration === null ? null : autoArchiveDuration,
+        rateLimitPerUser: slowmode, reason });
+    },
+    async setDefaultForumLayout(channelID, layout, reason): Promise<void> {
+      const channel = await guildChannel(client, channelID);
+      if (!channel.isForum()) throw new YuzuhaError('CHANNEL_FORUM', 'Layout padrão exige um canal de fórum.');
+      const value = layout === null ? null : { default: ForumLayout.Default, list: ForumLayout.List, grid: ForumLayout.Grid }[layout];
+      await channel.setDefaultForumLayout(value, reason);
+    },
     async move(channelID, position): Promise<void> {
       if (!Number.isSafeInteger(position) || position < 0) throw new YuzuhaError('POSITION', 'Posição deve ser um inteiro a partir de 0.');
       const channel = await guildChannel(client, channelID);