lunibee 0.1.7 → 0.1.8

package/dist/managers/guild-resources.d.ts

@@ -0,0 +1,109 @@
+import { Manager } from "./base.js";
+import { type REST } from "@lunibee/rest";
+import type { APIGuildScheduledEvent, APIStageInstance, UserData } from "@lunibee/types";
+/** Raw Discord ban object. */
+export interface APIBan {
+    user: UserData;
+    reason: string | null;
+}
+/** Options for {@link GuildBanManager.create}. */
+export interface GuildBanCreateOptions {
+    /** Seconds of message history to delete (0-604800). */
+    deleteMessageSeconds?: number;
+    /** Audit-log reason. */
+    reason?: string;
+}
+/** Manages a guild's bans, cached by user ID. Discord.js-familiar. */
+export declare class GuildBanManager extends Manager<string, APIBan> {
+    #private;
+    readonly guildId: string;
+    constructor(rest: REST, guildId: string);
+    /** Fetches one ban. */
+    fetch(userId: string): Promise<APIBan>;
+    /** Fetches a page of bans (`limit` 1-1000, `before`/`after` user-ID cursors). */
+    fetchAll(options?: {
+        limit?: number;
+        before?: string;
+        after?: string;
+    }): Promise<APIBan[]>;
+    /** Bans a user. */
+    create(userId: string, options?: GuildBanCreateOptions): Promise<void>;
+    /** Lifts a ban. */
+    remove(userId: string, reason?: string): Promise<void>;
+}
+/** Fields accepted when creating or editing a scheduled event. */
+export type GuildScheduledEventOptions = Partial<Omit<APIGuildScheduledEvent, "id" | "guild_id" | "creator" | "user_count">> & Record<string, unknown>;
+/** Manages a guild's scheduled events, cached by event ID. Discord.js-familiar. */
+export declare class GuildScheduledEventManager extends Manager<string, APIGuildScheduledEvent> {
+    #private;
+    readonly guildId: string;
+    constructor(rest: REST, guildId: string);
+    /** Fetches one event. */
+    fetch(eventId: string, options?: {
+        withUserCount?: boolean;
+    }): Promise<APIGuildScheduledEvent>;
+    /** Fetches every event in the guild. */
+    fetchAll(options?: {
+        withUserCount?: boolean;
+    }): Promise<APIGuildScheduledEvent[]>;
+    /** Creates an event. */
+    create(options: GuildScheduledEventOptions, reason?: string): Promise<APIGuildScheduledEvent>;
+    /** Edits an event. */
+    edit(eventId: string, options: GuildScheduledEventOptions, reason?: string): Promise<APIGuildScheduledEvent>;
+    /** Deletes an event. */
+    remove(eventId: string): Promise<void>;
+    /** Fetches users subscribed to an event (`limit` 1-100). */
+    fetchSubscribers(eventId: string, options?: {
+        limit?: number;
+        withMember?: boolean;
+        before?: string;
+        after?: string;
+    }): Promise<{
+        guild_scheduled_event_id: string;
+        user: UserData;
+    }[]>;
+}
+/** Options for creating a stage instance. */
+export interface StageInstanceCreateOptions {
+    topic: string;
+    privacyLevel?: number;
+    sendStartNotification?: boolean;
+    guildScheduledEventId?: string;
+}
+/** Manages stage instances, cached by stage channel ID. Discord.js-familiar. */
+export declare class StageInstanceManager extends Manager<string, APIStageInstance> {
+    #private;
+    constructor(rest: REST);
+    /** Starts a stage instance in a stage channel. */
+    create(channelId: string, options: StageInstanceCreateOptions, reason?: string): Promise<APIStageInstance>;
+    /** Fetches the stage instance of a stage channel. */
+    fetch(channelId: string): Promise<APIStageInstance>;
+    /** Edits a stage instance's topic or privacy level. */
+    edit(channelId: string, options: {
+        topic?: string;
+        privacyLevel?: number;
+    }, reason?: string): Promise<APIStageInstance>;
+    /** Ends a stage instance. */
+    remove(channelId: string, reason?: string): Promise<void>;
+}
+/** Overwrite target type: 0 = role, 1 = member. */
+export type PermissionOverwriteTargetType = 0 | 1;
+/** Permission values accepted by {@link PermissionOverwriteManager.edit}. */
+export interface PermissionOverwriteOptions {
+    /** Target type: 0 = role, 1 = member. */
+    type: PermissionOverwriteTargetType;
+    /** Allowed permission bits. */
+    allow?: bigint | number | string;
+    /** Denied permission bits. */
+    deny?: bigint | number | string;
+}
+/** Manages a channel's permission overwrites. Discord.js-familiar. */
+export declare class PermissionOverwriteManager {
+    #private;
+    readonly channelId: string;
+    constructor(rest: REST, channelId: string);
+    /** Creates or replaces the overwrite for a role or member. */
+    edit(overwriteId: string, options: PermissionOverwriteOptions, reason?: string): Promise<void>;
+    /** Deletes the overwrite for a role or member. */
+    remove(overwriteId: string, reason?: string): Promise<void>;
+}

package/dist/managers/guild.d.ts

@@ -1,4 +1,5 @@
 import { ResourceManager } from "./base.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";
@@ -10,6 +11,10 @@ export interface GuildEditOptions extends Record<string, unknown> {
 export declare class GuildManager extends ResourceManager<string, Guild> {
     #private;
     constructor(rest: REST);
+    /** Ban manager for a guild (one instance per guild). */
+    bans(guildId: string): GuildBanManager;
+    /** Scheduled-event manager for a guild (one instance per guild). */
+    scheduledEvents(guildId: string): GuildScheduledEventManager;
     /** Creates a new guild. (Bot must be in fewer than 10 guilds). */
     create(options: GuildCreateOptions): Promise<Guild>;
     /** Modifies a guild's settings. */

package/dist/managers/index.d.ts

@@ -1,5 +1,7 @@
 import { Manager } from "./base.js";
 export { Manager, ResourceManager } from "./base.js";
+/** Discord.js-familiar alias for {@link ResourceManager}. */
+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";
@@ -37,10 +39,13 @@ export interface ChannelCreateOptions extends Record<string, unknown> {
     parent_id?: string | null;
 }
 export type ChannelEditOptions = Record<string, unknown>;
+import { PermissionOverwriteManager } from "./guild-resources.js";
 export declare class ChannelManager extends Manager<string, Channel> {
     #private;
     constructor(rest: REST);
     messages(channelId: string): MessageManager;
+    /** Permission overwrite manager for a channel. */
+    permissionOverwrites(channelId: string): PermissionOverwriteManager;
     threads(channelId: string): ThreadManager;
     fetch(channelId: string): Promise<Channel>;
     resolve(channelId: string): Promise<Channel>;
@@ -104,4 +109,5 @@ 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 { EmojiManager, type EmojiCreateOptions, type EmojiEditOptions } from "./emoji.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";

package/dist/managers/index.js

@@ -285,7 +285,7 @@ class ResourceManager extends Manager {
 // packages/rest/package.json
 var package_default = {
   name: "@lunibee/rest",
-  version: "0.1.7",
+  version: "0.1.8",
   type: "module",
   module: "./src/index.ts",
   types: "./src/index.ts",
@@ -335,6 +335,8 @@ var Routes = {
   threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
   guildScheduledEvents: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events`,
   guildScheduledEvent: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}`,
+  guildScheduledEventUsers: (guildId, eventId) => `/guilds/${snowflake(guildId, "Guild ID")}/scheduled-events/${snowflake(eventId, "Event ID")}/users`,
+  channelPermission: (channelId, overwriteId) => `/channels/${snowflake(channelId, "Channel ID")}/permissions/${snowflake(overwriteId, "Overwrite ID")}`,
   guildAutoModerationRules: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules`,
   guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
   voiceRegions: () => "/voice/regions",
@@ -357,6 +359,7 @@ function snowflake(value, field) {
     throw new TypeError(`${field} must be a valid Discord snowflake.`);
   return value;
 }
+
 // packages/rest/src/index.ts
 var LIBRARY_VERSION = package_default.version;
 var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
@@ -490,6 +493,18 @@ class Channel extends BaseStructure {
   update(options) {
     return this.edit(options);
   }
+  isThread() {
+    return this.type === 10 || this.type === 11 || this.type === 12;
+  }
+  isTextBased() {
+    return [0, 1, 2, 3, 5, 10, 11, 12, 13].includes(this.type);
+  }
+  isVoiceBased() {
+    return this.type === 2 || this.type === 13;
+  }
+  isDMBased() {
+    return this.type === 1 || this.type === 3;
+  }
   toString() {
     return `<#${this.id}>`;
   }
@@ -1016,7 +1031,7 @@ class PermissionsBitField extends PermissionSet {
     super(value);
   }
 }
-// packages/types/src/index.ts
+// packages/types/src/gateway.ts
 var GatewayIntentBits = {
   Guilds: 1 << 0,
   GuildMembers: 1 << 1,
@@ -1068,6 +1083,37 @@ var IntentBits = {
   guildMessagePolls: 1 << 24,
   directMessagePolls: 1 << 25
 };
+// packages/ws/src/close-codes.ts
+var GatewayCloseCodes = {
+  UnknownError: 4000,
+  UnknownOpcode: 4001,
+  DecodeError: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  InvalidSeq: 4007,
+  RateLimited: 4008,
+  SessionTimedOut: 4009,
+  InvalidShard: 4010,
+  ShardingRequired: 4011,
+  InvalidAPIVersion: 4012,
+  InvalidIntents: 4013,
+  DisallowedIntents: 4014
+};
+
+// packages/ws/src/reconnect.ts
+var FATAL_CLOSE_CODES = [
+  GatewayCloseCodes.AuthenticationFailed,
+  GatewayCloseCodes.InvalidShard,
+  GatewayCloseCodes.ShardingRequired,
+  GatewayCloseCodes.InvalidAPIVersion,
+  GatewayCloseCodes.InvalidIntents,
+  GatewayCloseCodes.DisallowedIntents
+];
+var IDENTIFY_CLOSE_CODES = [
+  GatewayCloseCodes.InvalidSeq,
+  GatewayCloseCodes.SessionTimedOut
+];
 // packages/structures/src/resources.ts
 function toDateOrNull(value) {
   if (!value)
@@ -1165,6 +1211,15 @@ class Role extends BaseStructure {
     return `<@&${this.id}>`;
   }
 }
+
+class TextChannel extends Channel {
+  constructor(data, context) {
+    super(data, context);
+  }
+  toString() {
+    return `<#${this.id}>`;
+  }
+}
 class Emoji extends BaseStructure {
   name;
   roleIds;
@@ -1174,7 +1229,9 @@ class Emoji extends BaseStructure {
   animated;
   available;
   constructor(data) {
-    super(data.id ?? "unicode");
+    super(data.id ?? "0");
+    if (data.id === null)
+      this.id = "unicode";
     this.name = data.name;
     this.roleIds = data.roles ?? [];
     this.user = data.user ? new User(data.user) : null;
@@ -1237,6 +1294,106 @@ class AutoModerationRule extends BaseStructure {
     };
   }
 }
+// packages/structures/src/channels.ts
+class NewsChannel extends TextChannel {
+}
+
+class DMChannel extends Channel {
+  recipients;
+  ownerId;
+  constructor(data, context) {
+    super(data, context);
+    this.recipients = (data.recipients ?? []).map((u) => new User(u));
+    this.ownerId = data.owner_id ?? null;
+  }
+}
+
+class VoiceChannel extends Channel {
+  bitrate;
+  userLimit;
+  rtcRegion;
+  videoQualityMode;
+  constructor(data, context) {
+    super(data, context);
+    this.bitrate = data.bitrate ?? 64000;
+    this.userLimit = data.user_limit ?? 0;
+    this.rtcRegion = data.rtc_region ?? null;
+    this.videoQualityMode = data.video_quality_mode ?? 1;
+  }
+}
+
+class StageChannel extends VoiceChannel {
+}
+
+class CategoryChannel extends Channel {
+}
+
+class ThreadChannel extends Channel {
+  ownerId;
+  messageCount;
+  memberCount;
+  metadata;
+  constructor(data, context) {
+    super(data, context);
+    this.ownerId = data.owner_id ?? null;
+    this.messageCount = data.message_count ?? 0;
+    this.memberCount = data.member_count ?? 0;
+    this.metadata = data.thread_metadata ?? null;
+  }
+  get archived() {
+    return this.metadata?.archived ?? false;
+  }
+  get locked() {
+    return this.metadata?.locked ?? false;
+  }
+  get autoArchiveDuration() {
+    return this.metadata?.auto_archive_duration ?? null;
+  }
+}
+
+class ForumChannel extends Channel {
+  availableTags;
+  defaultReactionEmoji;
+  defaultThreadRateLimitPerUser;
+  defaultAutoArchiveDuration;
+  constructor(data, context) {
+    super(data, context);
+    this.availableTags = data.available_tags ?? [];
+    this.defaultReactionEmoji = data.default_reaction_emoji ?? null;
+    this.defaultThreadRateLimitPerUser = data.default_thread_rate_limit_per_user ?? 0;
+    this.defaultAutoArchiveDuration = data.default_auto_archive_duration ?? null;
+  }
+}
+
+class MediaChannel extends ForumChannel {
+}
+function createChannel(data, context) {
+  switch (data.type) {
+    case 0:
+      return new TextChannel(data, context);
+    case 1:
+    case 3:
+      return new DMChannel(data, context);
+    case 2:
+      return new VoiceChannel(data, context);
+    case 4:
+      return new CategoryChannel(data, context);
+    case 5:
+      return new NewsChannel(data, context);
+    case 10:
+    case 11:
+    case 12:
+      return new ThreadChannel(data, context);
+    case 13:
+      return new StageChannel(data, context);
+    case 15:
+      return new ForumChannel(data, context);
+    case 16:
+      return new MediaChannel(data, context);
+    default:
+      return new Channel(data, context);
+  }
+}
 // packages/structures/src/index.ts
 var NON_SYSTEM_MESSAGE_TYPES = new Set([0, 19, 20, 23]);
 
@@ -1452,7 +1609,7 @@ class ThreadManager {
       auto_archive_duration: options.autoArchiveDuration,
       rate_limit_per_user: options.rateLimitPerUser
     });
-    return new Channel(data, this.#context);
+    return createChannel(data, this.#context);
   }
 }
 
@@ -1480,18 +1637,173 @@ class UserManager extends ResourceManager {
     });
   }
 }
-// packages/managers/src/guild.ts
+// packages/managers/src/guild-resources.ts
 function withQuery(path, params) {
+  const query = new URLSearchParams;
+  for (const [key, value] of Object.entries(params))
+    if (value !== undefined)
+      query.set(key, String(value));
+  const suffix = query.toString();
+  return suffix ? `${path}?${suffix}` : path;
+}
+
+class GuildBanManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  async fetch(userId) {
+    const ban = await this.#rest.get(Routes.guildBan(this.guildId, userId));
+    this.set(ban.user.id, ban);
+    return ban;
+  }
+  async fetchAll(options = {}) {
+    const limit = options.limit === undefined ? undefined : Math.min(1000, Math.max(1, options.limit));
+    const bans = await this.#rest.get(withQuery(Routes.guildBans(this.guildId), {
+      limit,
+      before: options.before,
+      after: options.after
+    }));
+    for (const ban of bans)
+      this.set(ban.user.id, ban);
+    return bans;
+  }
+  async create(userId, options = {}) {
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
+  }
+  async remove(userId, reason) {
+    await this.#rest.delete(Routes.guildBan(this.guildId, userId), {
+      reason
+    });
+    this.delete(userId);
+  }
+}
+
+class GuildScheduledEventManager extends Manager {
+  #rest;
+  guildId;
+  constructor(rest, guildId) {
+    super();
+    this.#rest = rest;
+    this.guildId = guildId;
+  }
+  #store(event) {
+    this.set(event.id, event);
+    return event;
+  }
+  async fetch(eventId, options = {}) {
+    return this.#store(await this.#rest.get(withQuery(Routes.guildScheduledEvent(this.guildId, eventId), {
+      with_user_count: options.withUserCount
+    })));
+  }
+  async fetchAll(options = {}) {
+    const events = await this.#rest.get(withQuery(Routes.guildScheduledEvents(this.guildId), {
+      with_user_count: options.withUserCount
+    }));
+    return events.map((event) => this.#store(event));
+  }
+  async create(options, reason) {
+    return this.#store(await this.#rest.post(Routes.guildScheduledEvents(this.guildId), options, { reason }));
+  }
+  async edit(eventId, options, reason) {
+    return this.#store(await this.#rest.patch(Routes.guildScheduledEvent(this.guildId, eventId), options, { reason }));
+  }
+  async remove(eventId) {
+    await this.#rest.delete(Routes.guildScheduledEvent(this.guildId, eventId));
+    this.delete(eventId);
+  }
+  async fetchSubscribers(eventId, options = {}) {
+    const limit = options.limit === undefined ? undefined : Math.min(100, Math.max(1, options.limit));
+    return this.#rest.get(withQuery(Routes.guildScheduledEventUsers(this.guildId, eventId), {
+      limit,
+      with_member: options.withMember,
+      before: options.before,
+      after: options.after
+    }));
+  }
+}
+
+class StageInstanceManager extends Manager {
+  #rest;
+  constructor(rest) {
+    super();
+    this.#rest = rest;
+  }
+  #store(stage) {
+    this.set(stage.channel_id, stage);
+    return stage;
+  }
+  async create(channelId, options, reason) {
+    return this.#store(await this.#rest.post(Routes.stageInstances(), {
+      channel_id: channelId,
+      topic: options.topic,
+      privacy_level: options.privacyLevel,
+      send_start_notification: options.sendStartNotification,
+      guild_scheduled_event_id: options.guildScheduledEventId
+    }, { reason }));
+  }
+  async fetch(channelId) {
+    return this.#store(await this.#rest.get(Routes.stageInstanceByChannel(channelId)));
+  }
+  async edit(channelId, options, reason) {
+    return this.#store(await this.#rest.patch(Routes.stageInstanceByChannel(channelId), { topic: options.topic, privacy_level: options.privacyLevel }, { reason }));
+  }
+  async remove(channelId, reason) {
+    await this.#rest.delete(Routes.stageInstanceByChannel(channelId), {
+      reason
+    });
+    this.delete(channelId);
+  }
+}
+
+class PermissionOverwriteManager {
+  #rest;
+  channelId;
+  constructor(rest, channelId) {
+    this.#rest = rest;
+    this.channelId = channelId;
+  }
+  async edit(overwriteId, options, reason) {
+    await this.#rest.put(Routes.channelPermission(this.channelId, overwriteId), {
+      type: options.type,
+      allow: BigInt(options.allow ?? 0).toString(),
+      deny: BigInt(options.deny ?? 0).toString()
+    }, { reason });
+  }
+  async remove(overwriteId, reason) {
+    await this.#rest.delete(Routes.channelPermission(this.channelId, overwriteId), { reason });
+  }
+}
+
+// packages/managers/src/guild.ts
+function withQuery2(path, params) {
   const suffix = params.toString();
   return suffix ? `${path}?${suffix}` : path;
 }
 
 class GuildManager extends ResourceManager {
   #rest;
+  #bans = new Map;
+  #scheduledEvents = new Map;
   constructor(rest) {
     super(async (id) => new Guild(await rest.get(Routes.guild(id))), (guild) => guild.id);
     this.#rest = rest;
   }
+  bans(guildId) {
+    let manager = this.#bans.get(guildId);
+    if (!manager)
+      this.#bans.set(guildId, manager = new GuildBanManager(this.#rest, guildId));
+    return manager;
+  }
+  scheduledEvents(guildId) {
+    let manager = this.#scheduledEvents.get(guildId);
+    if (!manager)
+      this.#scheduledEvents.set(guildId, manager = new GuildScheduledEventManager(this.#rest, guildId));
+    return manager;
+  }
   async create(options) {
     const data = await this.#rest.post("/guilds", options);
     return this.upsert(new Guild(data));
@@ -1527,7 +1839,7 @@ class GuildManager extends ResourceManager {
       params.set("after", options.after);
     if (options.limit !== undefined)
       params.set("limit", String(Math.min(100, Math.max(1, options.limit))));
-    return this.#rest.get(withQuery(Routes.guildAuditLog(guildId), params));
+    return this.#rest.get(withQuery2(Routes.guildAuditLog(guildId), params));
   }
   async fetchMembers(guildId, options = {}) {
     const params = new URLSearchParams;
@@ -1535,7 +1847,7 @@ class GuildManager extends ResourceManager {
       params.set("limit", String(Math.min(1000, Math.max(1, options.limit))));
     if (options.after)
       params.set("after", options.after);
-    return this.#rest.get(withQuery(Routes.guildMembers(guildId), params));
+    return this.#rest.get(withQuery2(Routes.guildMembers(guildId), params));
   }
   async fetchAutoModerationRules(guildId) {
     const rules = await this.#rest.get(Routes.guildAutoModerationRules(guildId));
@@ -1666,9 +1978,7 @@ class GuildMemberManager extends ResourceManager {
     this.delete(userId);
   }
   async ban(userId, options = {}) {
-    await this.#rest.put(Routes.guildBan(this.guildId, userId), {
-      delete_message_seconds: options.deleteMessageSeconds
-    });
+    await this.#rest.put(Routes.guildBan(this.guildId, userId), { delete_message_seconds: options.deleteMessageSeconds }, { reason: options.reason });
     this.delete(userId);
   }
   async unban(userId) {
@@ -1800,6 +2110,9 @@ class ChannelManager extends Manager {
     }
     return manager;
   }
+  permissionOverwrites(channelId) {
+    return new PermissionOverwriteManager(this.#rest, channelId);
+  }
   threads(channelId) {
     return new ThreadManager(this.#rest, this.#context, channelId);
   }
@@ -1811,7 +2124,7 @@ class ChannelManager extends Manager {
   }
   upsert(data) {
     const existing = this.get(data.id);
-    const channel = new Channel(data, this.#context);
+    const channel = createChannel(data, this.#context);
     if (existing) {
       Object.assign(existing, channel);
       return existing;
@@ -1949,16 +2262,21 @@ function isMessageQuery(value) {
 export {
   ApplicationCommandManager,
   AuditLogEvent,
+  ResourceManager as CachedManager,
   ChannelManager,
   EmojiManager,
+  GuildBanManager,
   GuildManager,
   GuildMemberManager,
+  GuildScheduledEventManager,
   Manager,
   MessageManager,
+  PermissionOverwriteManager,
   ResourceManager,
   RoleManager,
+  StageInstanceManager,
   ThreadManager,
   UserManager
 };
 
-//# debugId=EA438691ADA8387364756E2164756E21
+//# debugId=E5CAD3E6B2BD672164756E2164756E21