lunibee 0.1.8 → 0.2.0

package/dist/managers/advanced.d.ts

@@ -0,0 +1,116 @@
+import { Manager } from "./base.js";
+import { type REST } from "@lunibee/rest";
+import type { APIEntitlement, APISKU, APISoundboardSound, APISticker, APISubscription } from "@lunibee/types";
+export type { APIEntitlement, APISKU, APISoundboardSound, APISubscription, } from "@lunibee/types";
+/** Fields for {@link GuildStickerManager.create}. */
+export interface GuildStickerCreateOptions {
+    name: string;
+    description: string;
+    /** Autocomplete/suggestion tags (e.g. an emoji name). */
+    tags: string;
+    /** PNG, APNG, GIF or Lottie JSON file, max 512 KiB. */
+    file: Blob;
+    reason?: string;
+}
+/** Manages a guild's custom stickers, cached by sticker ID. */
+export declare class GuildStickerManager extends Manager<string, APISticker> {
+    #private;
+    readonly guildId: string;
+    constructor(rest: REST, guildId: string);
+    /** Fetches every sticker in the guild, replacing the cache. */
+    fetchAll(): Promise<APISticker[]>;
+    /** Fetches one sticker. */
+    fetch(stickerId: string): Promise<APISticker>;
+    /** Uploads a sticker (multipart form, as Discord requires). */
+    create(options: GuildStickerCreateOptions): Promise<APISticker>;
+    /** Edits a sticker's name, description or tags. */
+    edit(stickerId: string, options: {
+        name?: string;
+        description?: string | null;
+        tags?: string;
+        reason?: string;
+    }): Promise<APISticker>;
+    /** Deletes a sticker. */
+    remove(stickerId: string, reason?: string): Promise<void>;
+    /** Replaces the cache with the full list from a `GUILD_STICKERS_UPDATE` event. */
+    sync(stickers: readonly APISticker[]): void;
+}
+/** Fields for {@link GuildSoundboardManager.create}. */
+export interface SoundboardSoundCreateOptions {
+    name: string;
+    /** Data URI of an MP3 or OGG file (max 512 KiB, 5.2 s). */
+    sound: string;
+    /** 0 to 1; defaults to 1. */
+    volume?: number;
+    emojiId?: string;
+    emojiName?: string;
+    reason?: string;
+}
+/** Manages a guild's soundboard sounds, cached by sound ID. */
+export declare class GuildSoundboardManager extends Manager<string, APISoundboardSound> {
+    #private;
+    readonly guildId: string;
+    constructor(rest: REST, guildId: string);
+    /** Fetches every soundboard sound in the guild, replacing the cache. */
+    fetchAll(): Promise<APISoundboardSound[]>;
+    /** Fetches one sound. */
+    fetch(soundId: string): Promise<APISoundboardSound>;
+    /** Creates a sound. */
+    create(options: SoundboardSoundCreateOptions): Promise<APISoundboardSound>;
+    /** Edits a sound's name, volume or emoji. */
+    edit(soundId: string, options: {
+        name?: string;
+        volume?: number | null;
+        emojiId?: string | null;
+        emojiName?: string | null;
+        reason?: string;
+    }): Promise<APISoundboardSound>;
+    /** Deletes a sound. */
+    remove(soundId: string, reason?: string): Promise<void>;
+}
+/** Filters for {@link MonetizationManager.fetchEntitlements}. */
+export interface EntitlementQuery {
+    userId?: string;
+    skuIds?: string[];
+    guildId?: string;
+    before?: string;
+    after?: string;
+    /** 1-100, default 100. */
+    limit?: number;
+    excludeEnded?: boolean;
+    excludeDeleted?: boolean;
+}
+/**
+ * SKUs, entitlements and subscriptions for one application. Entitlements are
+ * cached by ID and kept current by the client's `ENTITLEMENT_*` events.
+ */
+export declare class MonetizationManager extends Manager<string, APIEntitlement> {
+    #private;
+    readonly applicationId: string;
+    constructor(rest: REST, applicationId: string);
+    /** Fetches the application's SKUs. */
+    fetchSkus(): Promise<APISKU[]>;
+    /** Fetches entitlements matching the filters and caches them. */
+    fetchEntitlements(query?: EntitlementQuery): Promise<APIEntitlement[]>;
+    /** Fetches one entitlement. */
+    fetch(entitlementId: string): Promise<APIEntitlement>;
+    /** Marks a one-time-purchase entitlement as consumed. */
+    consume(entitlementId: string): Promise<void>;
+    /** Creates a test entitlement for a user or guild (owner type 1 = guild, 2 = user). */
+    createTestEntitlement(options: {
+        skuId: string;
+        ownerId: string;
+        ownerType: 1 | 2;
+    }): Promise<APIEntitlement>;
+    /** Deletes a test entitlement. */
+    deleteTestEntitlement(entitlementId: string): Promise<void>;
+    /** Fetches a SKU's subscriptions for a user, or one subscription. */
+    fetchSubscriptions(skuId: string, query?: {
+        userId?: string;
+        before?: string;
+        after?: string;
+        limit?: number;
+    }): Promise<APISubscription[]>;
+    /** Fetches one subscription. */
+    fetchSubscription(skuId: string, subscriptionId: string): Promise<APISubscription>;
+}

package/dist/managers/base.d.ts

@@ -1,10 +1,20 @@
 import { Collection } from "@lunibee/collection";
 /** Generic cache manager. @typeParam K Cache key type. @typeParam V Cached value type. */
 export declare class Manager<K, V> {
-    /** Cached resources. */ readonly cache: Collection<K, V>;
+    #private;
+    /** Authoritative resource state. Entries never expire: see {@link Manager.set}. */ readonly cache: Collection<K, V>;
     /** Gets a cached value. @param id Cache key. @returns Cached value. */ get(id: K): V | undefined;
     /** Checks whether a value is cached. @param id Cache key. @returns True when cached. */ has(id: K): boolean;
-    /** Stores a value. @param id Cache key. @param value Value. @returns This manager. */ set(id: K, value: V): this;
+    /**
+     * Runs a REST load for one key. Concurrent loads of that key share a
+     * single request. If the key is written (e.g. by a Gateway update) or
+     * deleted while the request is in flight, the result is returned but not
+     * stored, so it cannot overwrite fresher state or resurrect a deleted
+     * resource.
+     * @param store Stores a fresh result and returns the canonical instance.
+     */
+    protected fetchOnce(id: K, load: () => Promise<V>, store?: (value: V) => V): Promise<V>;
+    /** Stores a resource with `setWithoutTTL()`, so it leaves only on an explicit delete (e.g. a Gateway `*_DELETE`), never through TTL. @param id Cache key. @param value Value. @returns This manager. */ set(id: K, value: V): this;
     /** Deletes a cached value. @param id Cache key. @returns True when deleted. */ delete(id: K): boolean;
     /** Clears the cache. @returns Nothing. */ clear(): void;
     /** Gets cache size. @returns Number of cached values. */ get size(): number;
@@ -23,6 +33,7 @@ export declare class ResourceManager<K, V> extends Manager<K, V> {
     resolve(id: K): Promise<V>;
     fetch(id: K): Promise<V>;
     fetchMany(ids: Iterable<K>): Promise<V[]>;
+    /** Stores a resource, merging into the cached instance when there is one so existing references stay current. @returns The canonical instance. */
     upsert(resource: V): V;
     update(resource: V): V;
 }

package/dist/managers/emoji.d.ts

@@ -21,7 +21,7 @@ export interface EmojiEditOptions {
 export declare class EmojiManager extends Manager<string, Emoji> {
     #private;
     constructor(rest: REST, guildId: string);
-    /** Fetches an emoji by ID from Discord. */
+    /** Fetches an emoji by ID; concurrent fetches share a request and a stale result never overwrites newer state. */
     fetch(emojiId: string): Promise<Emoji>;
     /** Fetches all emojis for this guild. */
     fetchAll(): Promise<Emoji[]>;

package/dist/managers/guild.d.ts

@@ -1,8 +1,13 @@
-import { ResourceManager } from "./base.js";
+import { Manager, ResourceManager } from "./base.js";
+import { EmojiManager } from "./emoji.js";
+import { GuildSoundboardManager, GuildStickerManager } from "./advanced.js";
+import { GuildMemberManager } from "./member.js";
+import { RoleManager } from "./role.js";
 import { GuildBanManager, GuildScheduledEventManager } from "./guild-resources.js";
 import { Guild, AutoModerationRule } from "@lunibee/structures";
 import { type REST } from "@lunibee/rest";
-import { type APIChannel, type APIGuildPreview, type APIInvite, type APIWebhook } from "@lunibee/types";
+import { type APIChannel, type APIGuildPreview, type APIInvite, type APIWebhook, type APIAutoModerationRule, type APIInviteCreate, type APIVoiceState } from "@lunibee/types";
+type GuildData = ConstructorParameters<typeof Guild>[0];
 export interface GuildCreateOptions extends Record<string, unknown> {
     name: string;
 }
@@ -15,6 +20,26 @@ export declare class GuildManager extends ResourceManager<string, Guild> {
     bans(guildId: string): GuildBanManager;
     /** Scheduled-event manager for a guild (one instance per guild). */
     scheduledEvents(guildId: string): GuildScheduledEventManager;
+    /** Member manager for a guild (one instance per guild, kept in sync by the Gateway). */
+    members(guildId: string): GuildMemberManager;
+    /** Role manager for a guild (one instance per guild, kept in sync by the Gateway). */
+    roles(guildId: string): RoleManager;
+    /** Emoji manager for a guild (one instance per guild, kept in sync by the Gateway). */
+    emojis(guildId: string): EmojiManager;
+    /** Sticker manager for a guild (one instance per guild, kept in sync by the Gateway). */
+    stickers(guildId: string): GuildStickerManager;
+    /** Soundboard manager for a guild (one instance per guild, kept in sync by the Gateway). */
+    soundboard(guildId: string): GuildSoundboardManager;
+    /** Voice states by user ID for a guild, kept in sync by `GUILD_CREATE` and `VOICE_STATE_UPDATE`. */
+    voiceStates(guildId: string): Manager<string, APIVoiceState>;
+    /** Auto-moderation rules by ID for a guild, kept in sync by `AUTO_MODERATION_RULE_*` events. */
+    autoModerationRules(guildId: string): Manager<string, APIAutoModerationRule>;
+    /** Invites by code for a guild, kept in sync by `INVITE_CREATE` / `INVITE_DELETE`. */
+    invites(guildId: string): Manager<string, APIInviteCreate>;
+    /** Merges a guild payload into the cached instance, keeping object identity. */
+    patch(data: GuildData): Guild;
+    /** Removes a guild and every per-guild manager that belongs to it. */
+    delete(id: string): boolean;
     /** Creates a new guild. (Bot must be in fewer than 10 guilds). */
     create(options: GuildCreateOptions): Promise<Guild>;
     /** Modifies a guild's settings. */
@@ -144,3 +169,4 @@ export declare const AuditLogEvent: {
     readonly AutoModerationRuleDelete: 142;
     readonly AutoModerationBlockMessage: 143;
 };
+export {};

package/dist/managers/index.d.ts

@@ -4,7 +4,7 @@ export { Manager, ResourceManager } from "./base.js";
 export { ResourceManager as CachedManager } from "./base.js";
 import { REST } from "@lunibee/rest";
 import { Channel, Message, User } from "@lunibee/structures";
-import { MessageManager, type MessageCreateOptions as ManagerMessageCreateOptions } from "./message.js";
+import { MessageManager, type MessageCacheOptions, type MessageCreateOptions as ManagerMessageCreateOptions } from "./message.js";
 import { ThreadManager } from "./thread.js";
 export { UserManager } from "./user.js";
 export { GuildManager } from "./guild.js";
@@ -42,15 +42,35 @@ export type ChannelEditOptions = Record<string, unknown>;
 import { PermissionOverwriteManager } from "./guild-resources.js";
 export declare class ChannelManager extends Manager<string, Channel> {
     #private;
-    constructor(rest: REST);
+    /** @param options.messageCache Enables a bounded per-channel message cache; messages are not cached by default. */
+    constructor(rest: REST, options?: {
+        messageCache?: MessageCacheOptions;
+    });
     messages(channelId: string): MessageManager;
     /** Permission overwrite manager for a channel. */
     permissionOverwrites(channelId: string): PermissionOverwriteManager;
     threads(channelId: string): ThreadManager;
+    /** Fetches a channel; concurrent fetches share a request and a stale result never overwrites newer state. */
     fetch(channelId: string): Promise<Channel>;
     resolve(channelId: string): Promise<Channel>;
     upsert(data: ConstructorParameters<typeof Channel>[0]): Channel;
     update(channel: Channel): this;
+    /** Removes every cached channel that belongs to a guild. @returns Number removed. */
+    deleteGuildChannels(guildId: string): number;
+    /** Ends a poll now; returns the updated message. */
+    endPoll(channelId: string, messageId: string): Promise<Message>;
+    /** Fetches users who voted for one poll answer. @param options.limit 1-100 (default 25). */
+    fetchPollVoters(channelId: string, messageId: string, answerId: number, options?: {
+        after?: string;
+        limit?: number;
+    }): Promise<User[]>;
+    /** Plays a soundboard sound in a voice channel the bot is connected to. */
+    sendSoundboardSound(channelId: string, options: {
+        soundId: string;
+        sourceGuildId?: string;
+    }): Promise<void>;
+    /** Returns the message manager for a channel only if one already exists. */
+    cachedMessages(channelId: string): MessageManager | undefined;
     create(guildId: string, options: ChannelCreateOptions): Promise<Channel>;
     edit(channelId: string, options: ChannelEditOptions): Promise<Channel>;
     deleteChannel(channelId: string): Promise<void>;
@@ -69,9 +89,20 @@ export declare class ChannelManager extends Manager<string, Channel> {
     deleteMessage(channelId: string, messageId: string): Promise<void>;
     deleteCachedMessage(channelId: string, messageId: string): boolean;
     crosspostMessage(channelId: string, messageId: string): Promise<Message>;
-    /** Bulk-deletes messages in a channel.
-     * @throws {RangeError} If fewer than 2 or more than 100 message IDs are provided. */
+    /** Bulk-deletes messages in a channel. Duplicate IDs are ignored and a
+     * single ID falls back to a normal delete.
+     * @throws {RangeError} If no IDs or more than 100 are provided, or any
+     * message is older than 14 days (Discord refuses to bulk-delete those). */
     bulkDeleteMessages(channelId: string, messageIds: Iterable<string>): Promise<void>;
+    /**
+     * Iterates a channel's history newest-first, 100 messages per request,
+     * starting before `before` (or the latest message) and stopping after
+     * `limit` messages or at the start of the channel.
+     */
+    iterateMessages(channelId: string, options?: {
+        before?: string;
+        limit?: number;
+    }): AsyncGenerator<Message, void, undefined>;
     addReaction(channelId: string, messageId: string, emoji: string): Promise<void>;
     fetchReactions(channelId: string, messageId: string, emoji: string, options?: ReactionFetchOptions): Promise<User[]>;
     removeOwnReaction(channelId: string, messageId: string, emoji: string): Promise<void>;
@@ -104,10 +135,11 @@ export declare class ChannelManager extends Manager<string, Channel> {
     clear(): void;
 }
 export type CreateMessageOptions = MessageCreateOptions;
-export { MessageManager } from "./message.js";
+export { MessageManager, type MessageCacheOptions } from "./message.js";
 export { ThreadManager } from "./thread.js";
 export { RoleManager, type RoleCreateOptions, type RoleEditOptions, } from "./role.js";
 export { GuildMemberManager, type MemberEditOptions, type BanOptions, } from "./member.js";
 export { ApplicationCommandManager } from "./application.js";
 export { GuildBanManager, GuildScheduledEventManager, StageInstanceManager, PermissionOverwriteManager, type APIBan, type GuildBanCreateOptions, type GuildScheduledEventOptions, type StageInstanceCreateOptions, type PermissionOverwriteOptions, type PermissionOverwriteTargetType, } from "./guild-resources.js";
 export { EmojiManager, type EmojiCreateOptions, type EmojiEditOptions, } from "./emoji.js";
+export { GuildStickerManager, GuildSoundboardManager, MonetizationManager, type APIEntitlement, type APISKU, type APISoundboardSound, type APISubscription, type EntitlementQuery, type GuildStickerCreateOptions, type SoundboardSoundCreateOptions, } from "./advanced.js";