@takaro/modules 0.0.0-next.0da151e

package/src/dto/takaroEvents.ts

@@ -0,0 +1,525 @@
+import {
+  IsArray,
+  IsBoolean,
+  IsEnum,
+  IsIP,
+  IsISO31661Alpha2,
+  IsJSON,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  IsUUID,
+  ValidateNested,
+} from 'class-validator';
+import { BaseEvent } from './base.js';
+import { ValueOf } from 'type-fest';
+import { Type } from 'class-transformer';
+import { TakaroDTO } from '@takaro/util';
+
+export const TakaroEvents = {
+  ROLE_ASSIGNED: 'role-assigned',
+  ROLE_REMOVED: 'role-removed',
+  ROLE_CREATED: 'role-created',
+  ROLE_UPDATED: 'role-updated',
+  ROLE_DELETED: 'role-deleted',
+  COMMAND_EXECUTED: 'command-executed',
+  COMMAND_EXECUTION_DENIED: 'command-execution-denied',
+  HOOK_EXECUTED: 'hook-executed',
+  CRONJOB_EXECUTED: 'cronjob-executed',
+  CURRENCY_ADDED: 'currency-added',
+  CURRENCY_DEDUCTED: 'currency-deducted',
+  CURRENCY_RESET_ALL: 'currency-reset-all',
+  SETTINGS_SET: 'settings-set',
+  PLAYER_NEW_IP_DETECTED: 'player-new-ip-detected',
+  PLAYER_NEW_NAME_DETECTED: 'player-new-name-detected',
+  SERVER_STATUS_CHANGED: 'server-status-changed',
+  MODULE_CREATED: 'module-created',
+  MODULE_UPDATED: 'module-updated',
+  MODULE_DELETED: 'module-deleted',
+  MODULE_INSTALLED: 'module-installed',
+  MODULE_UNINSTALLED: 'module-uninstalled',
+  PLAYER_CREATED: 'player-created',
+  SHOP_LISTING_CREATED: 'shop-listing-created',
+  SHOP_LISTING_UPDATED: 'shop-listing-updated',
+  SHOP_LISTING_DELETED: 'shop-listing-deleted',
+  SHOP_ORDER_CREATED: 'shop-order-created',
+  SHOP_ORDER_STATUS_CHANGED: 'shop-order-status-changed',
+  SHOP_ORDER_DELIVERY_FAILED: 'shop-order-delivery-failed',
+  PLAYER_LINKED: 'player-linked',
+  GAMESERVER_CREATED: 'gameserver-created',
+  GAMESERVER_UPDATED: 'gameserver-updated',
+  GAMESERVER_DELETED: 'gameserver-deleted',
+  PLAYER_BANNED: 'player-banned',
+  PLAYER_UNBANNED: 'player-unbanned',
+  PLAYER_DELETED: 'player-deleted',
+} as const;
+
+export class BaseTakaroEvent<T> extends BaseEvent<T> {
+  @IsEnum(TakaroEvents)
+  declare type: ValueOf<typeof TakaroEvents>;
+
+  @IsString()
+  msg: string;
+}
+
+export class TakaroEventPlayerNewIpDetected extends BaseEvent<TakaroEventPlayerNewIpDetected> {
+  @IsString()
+  type = TakaroEvents.PLAYER_NEW_IP_DETECTED;
+
+  @IsISO31661Alpha2()
+  country: string;
+
+  @IsString()
+  city: string;
+
+  @IsString()
+  longitude: string;
+
+  @IsString()
+  latitude: string;
+
+  @IsIP()
+  ip: string;
+}
+
+export class TakaroEventPlayerNewNameDetected extends BaseEvent<TakaroEventPlayerNewNameDetected> {
+  @IsString()
+  type = TakaroEvents.PLAYER_NEW_NAME_DETECTED;
+
+  @IsString()
+  @IsOptional()
+  oldName: string | null;
+
+  @IsString()
+  newName: string;
+}
+
+export class TakaroEventCurrencyDeducted extends BaseEvent<TakaroEventCurrencyDeducted> {
+  @IsString()
+  type = TakaroEvents.CURRENCY_DEDUCTED;
+
+  @IsNumber()
+  amount: number;
+}
+
+export class TakaroEventCurrencyAdded extends BaseEvent<TakaroEventCurrencyAdded> {
+  @IsString()
+  type = TakaroEvents.CURRENCY_ADDED;
+
+  @IsNumber()
+  amount: number;
+}
+
+export class TakaroEventCurrencyResetAll extends BaseEvent<TakaroEventCurrencyResetAll> {
+  @IsString()
+  type = TakaroEvents.CURRENCY_RESET_ALL;
+
+  @IsNumber()
+  affectedPlayerCount: number;
+}
+
+export class TakaroEventFunctionResult extends TakaroDTO<TakaroEventFunctionResult> {
+  @ValidateNested({ each: true })
+  @Type(() => TakaroEventFunctionLog)
+  logs: TakaroEventFunctionLog[];
+
+  @IsBoolean()
+  success: boolean;
+
+  @IsString()
+  @IsOptional()
+  reason: string;
+
+  @IsNumber()
+  @IsOptional()
+  tryAgainIn: number;
+}
+
+export class TakaroEventFunctionLog extends TakaroDTO<TakaroEventFunctionLog> {
+  @IsString()
+  msg: string;
+
+  @IsOptional()
+  details: Record<string, unknown> | string | undefined;
+}
+
+export class TakaroEventCommandDetails extends TakaroDTO<TakaroEventCommandDetails> {
+  @IsString()
+  id: string;
+  @IsString()
+  name: string;
+  @IsObject()
+  arguments: Record<string, unknown>;
+}
+
+export class TakaroEventHookDetails extends TakaroDTO<TakaroEventHookDetails> {
+  @IsString()
+  id: string;
+  @IsString()
+  name: string;
+}
+
+export class TakaroEventCronjobDetails extends TakaroDTO<TakaroEventCronjobDetails> {
+  @IsString()
+  id: string;
+  @IsString()
+  name: string;
+}
+
+export class TakaroEventCommandExecuted extends BaseEvent<TakaroEventCommandExecuted> {
+  @IsString()
+  type = TakaroEvents.COMMAND_EXECUTED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventFunctionResult)
+  result: TakaroEventFunctionResult;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => TakaroEventCommandDetails)
+  command: TakaroEventCommandDetails;
+}
+
+export class TakaroEventCommandExecutionDenied extends BaseEvent<TakaroEventCommandExecutionDenied> {
+  @IsString()
+  type = TakaroEvents.COMMAND_EXECUTION_DENIED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventCommandDetails)
+  command: TakaroEventCommandDetails;
+
+  @IsArray()
+  @IsString({ each: true })
+  missingPermissions: string[];
+}
+
+export class TakaroEventHookExecuted extends BaseEvent<TakaroEventHookExecuted> {
+  @IsString()
+  type = TakaroEvents.HOOK_EXECUTED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventFunctionResult)
+  result: TakaroEventFunctionResult;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => TakaroEventHookDetails)
+  hook: TakaroEventHookDetails;
+}
+
+export class TakaroEventCronjobExecuted extends BaseEvent<TakaroEventCronjobExecuted> {
+  @IsString()
+  type = TakaroEvents.CRONJOB_EXECUTED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventFunctionResult)
+  result: TakaroEventFunctionResult;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => TakaroEventCronjobDetails)
+  cronjob: TakaroEventCronjobDetails;
+}
+
+export class TakaroEventRoleMeta extends TakaroDTO<TakaroEventRoleMeta> {
+  @IsString()
+  id: string;
+  @IsString()
+  name: string;
+}
+
+export class TakaroEventRoleAssigned extends BaseEvent<TakaroEventRoleAssigned> {
+  @IsString()
+  type = TakaroEvents.ROLE_ASSIGNED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleRemoved extends BaseEvent<TakaroEventRoleRemoved> {
+  @IsString()
+  type = TakaroEvents.ROLE_REMOVED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleCreated extends BaseEvent<TakaroEventRoleCreated> {
+  @IsString()
+  type = TakaroEvents.ROLE_CREATED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleUpdated extends BaseEvent<TakaroEventRoleUpdated> {
+  @IsString()
+  type = TakaroEvents.ROLE_UPDATED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventRoleDeleted extends BaseEvent<TakaroEventRoleDeleted> {
+  @IsString()
+  type = TakaroEvents.ROLE_DELETED;
+
+  @ValidateNested()
+  @Type(() => TakaroEventRoleMeta)
+  role: TakaroEventRoleMeta;
+}
+
+export class TakaroEventSettingsSet extends BaseEvent<TakaroEventSettingsSet> {
+  @IsString()
+  type = TakaroEvents.SETTINGS_SET;
+
+  @IsString()
+  key: string;
+
+  @IsString()
+  @IsOptional()
+  value: string | null;
+}
+
+export class TakaroEventServerStatusChanged extends BaseEvent<TakaroEventServerStatusChanged> {
+  @IsString()
+  type = TakaroEvents.SERVER_STATUS_CHANGED;
+
+  @IsString()
+  status: string;
+
+  @IsOptional()
+  details?: Record<string, unknown> | string | null;
+}
+
+export class TakaroEventModuleCreated extends BaseEvent<TakaroEventModuleCreated> {
+  @IsString()
+  type = TakaroEvents.MODULE_CREATED;
+}
+
+export class TakaroEventModuleUpdated extends BaseEvent<TakaroEventModuleUpdated> {
+  @IsString()
+  type = TakaroEvents.MODULE_UPDATED;
+
+  @IsString()
+  @IsOptional()
+  changeType?: 'created' | 'updated' | 'deleted';
+
+  @IsString()
+  @IsOptional()
+  componentType?: 'command' | 'hook' | 'cronjob' | 'permission' | 'function' | 'module';
+
+  @IsString()
+  @IsOptional()
+  componentName?: string;
+
+  @IsString()
+  @IsOptional()
+  componentId?: string;
+
+  @IsOptional()
+  previousValue?: Record<string, unknown>;
+
+  @IsOptional()
+  newValue?: Record<string, unknown>;
+}
+
+export class TakaroEventModuleDeleted extends BaseEvent<TakaroEventModuleDeleted> {
+  @IsString()
+  type = TakaroEvents.MODULE_DELETED;
+}
+
+export class TakaroEventModuleInstalled extends BaseEvent<TakaroEventModuleInstalled> {
+  @IsString()
+  type = TakaroEvents.MODULE_INSTALLED;
+
+  @IsJSON()
+  userConfig: string;
+
+  @IsJSON()
+  systemConfig: string;
+}
+
+export class TakaroEventModuleUninstalled extends BaseEvent<TakaroEventModuleUninstalled> {
+  @IsString()
+  type = TakaroEvents.MODULE_UNINSTALLED;
+}
+export class TakaroEventPlayerCreated extends BaseEvent<TakaroEventPlayerCreated> {
+  @IsString()
+  type = TakaroEvents.PLAYER_CREATED;
+}
+
+export class TakaroEventShopListingCreated extends BaseEvent<TakaroEventShopListingCreated> {
+  @IsString()
+  type = TakaroEvents.SHOP_LISTING_CREATED;
+  @IsUUID()
+  id: string;
+}
+
+export class TakaroEventShopListingUpdated extends BaseEvent<TakaroEventShopListingUpdated> {
+  @IsString()
+  type = TakaroEvents.SHOP_LISTING_UPDATED;
+  @IsUUID()
+  id: string;
+}
+
+export class TakaroEventShopListingDeleted extends BaseEvent<TakaroEventShopListingDeleted> {
+  @IsString()
+  type = TakaroEvents.SHOP_LISTING_DELETED;
+  @IsUUID()
+  id: string;
+}
+
+export class TakaroEventShopOrderCreated extends BaseEvent<TakaroEventShopOrderCreated> {
+  @IsString()
+  type = TakaroEvents.SHOP_ORDER_CREATED;
+  @IsUUID()
+  id: string;
+  @IsString()
+  listingName: string;
+  @IsNumber()
+  price: number;
+  @IsNumber()
+  amount: number;
+  @IsNumber()
+  totalPrice: number;
+  @ValidateNested({ each: true })
+  @Type(() => TakaroEventShopItem)
+  @IsOptional()
+  items?: TakaroEventShopItem[];
+}
+
+export class TakaroEventShopItem extends TakaroDTO<TakaroEventShopItem> {
+  @IsString()
+  name: string;
+  @IsString()
+  code: string;
+  @IsNumber()
+  amount: number;
+  @IsString()
+  @IsOptional()
+  quality?: string;
+}
+
+export class TakaroEventShopOrderStatusChanged extends BaseEvent<TakaroEventShopOrderStatusChanged> {
+  @IsString()
+  type = TakaroEvents.SHOP_ORDER_STATUS_CHANGED;
+  @IsUUID()
+  id: string;
+  @IsString()
+  status: string;
+}
+
+export class TakaroEventShopOrderDeliveryFailed extends BaseEvent<TakaroEventShopOrderDeliveryFailed> {
+  @IsString()
+  type = TakaroEvents.SHOP_ORDER_DELIVERY_FAILED;
+  @IsUUID()
+  id: string;
+  @IsString()
+  error: string;
+  @ValidateNested({ each: true })
+  @Type(() => TakaroEventShopItem)
+  items: TakaroEventShopItem[];
+}
+
+export class TakaroEventPlayerLinked extends BaseEvent<TakaroEventPlayerLinked> {
+  @IsString()
+  type = TakaroEvents.PLAYER_LINKED;
+}
+
+export class TakaroEventGameserverCreated extends BaseEvent<TakaroEventGameserverCreated> {
+  @IsString()
+  type = TakaroEvents.GAMESERVER_CREATED;
+}
+
+export class TakaroEventGameserverUpdated extends BaseEvent<TakaroEventGameserverUpdated> {
+  @IsString()
+  type = TakaroEvents.GAMESERVER_UPDATED;
+}
+
+export class TakaroEventGameserverDeleted extends BaseEvent<TakaroEventGameserverDeleted> {
+  @IsString()
+  type = TakaroEvents.GAMESERVER_DELETED;
+}
+
+export class TakaroEventPlayerBanned extends BaseEvent<TakaroEventPlayerBanned> {
+  @IsString()
+  type = TakaroEvents.PLAYER_BANNED;
+
+  @IsString()
+  @IsOptional()
+  reason?: string;
+
+  @IsString()
+  @IsOptional()
+  until?: string;
+
+  @IsBoolean()
+  isGlobal: boolean;
+
+  @IsBoolean()
+  takaroManaged: boolean;
+}
+
+export class TakaroEventPlayerUnbanned extends BaseEvent<TakaroEventPlayerUnbanned> {
+  @IsString()
+  type = TakaroEvents.PLAYER_UNBANNED;
+
+  @IsBoolean()
+  isGlobal: boolean;
+
+  @IsBoolean()
+  takaroManaged: boolean;
+}
+
+export class TakaroEventPlayerDeleted extends BaseEvent<TakaroEventPlayerDeleted> {
+  @IsString()
+  type = TakaroEvents.PLAYER_DELETED;
+
+  @IsString()
+  @IsOptional()
+  playerName?: string;
+}
+
+export const TakaroEventsMapping = {
+  [TakaroEvents.ROLE_ASSIGNED]: TakaroEventRoleAssigned,
+  [TakaroEvents.PLAYER_NEW_IP_DETECTED]: TakaroEventPlayerNewIpDetected,
+  [TakaroEvents.PLAYER_NEW_NAME_DETECTED]: TakaroEventPlayerNewNameDetected,
+  [TakaroEvents.CURRENCY_DEDUCTED]: TakaroEventCurrencyDeducted,
+  [TakaroEvents.CURRENCY_ADDED]: TakaroEventCurrencyAdded,
+  [TakaroEvents.CURRENCY_RESET_ALL]: TakaroEventCurrencyResetAll,
+  [TakaroEvents.COMMAND_EXECUTED]: TakaroEventCommandExecuted,
+  [TakaroEvents.COMMAND_EXECUTION_DENIED]: TakaroEventCommandExecutionDenied,
+  [TakaroEvents.ROLE_REMOVED]: TakaroEventRoleRemoved,
+  [TakaroEvents.ROLE_CREATED]: TakaroEventRoleCreated,
+  [TakaroEvents.ROLE_UPDATED]: TakaroEventRoleUpdated,
+  [TakaroEvents.ROLE_DELETED]: TakaroEventRoleDeleted,
+  [TakaroEvents.SETTINGS_SET]: TakaroEventSettingsSet,
+  [TakaroEvents.HOOK_EXECUTED]: TakaroEventHookExecuted,
+  [TakaroEvents.CRONJOB_EXECUTED]: TakaroEventCronjobExecuted,
+  [TakaroEvents.SERVER_STATUS_CHANGED]: TakaroEventServerStatusChanged,
+  [TakaroEvents.MODULE_CREATED]: TakaroEventModuleCreated,
+  [TakaroEvents.MODULE_UPDATED]: TakaroEventModuleUpdated,
+  [TakaroEvents.MODULE_DELETED]: TakaroEventModuleDeleted,
+  [TakaroEvents.MODULE_INSTALLED]: TakaroEventModuleInstalled,
+  [TakaroEvents.MODULE_UNINSTALLED]: TakaroEventModuleUninstalled,
+  [TakaroEvents.PLAYER_CREATED]: TakaroEventPlayerCreated,
+  [TakaroEvents.SHOP_LISTING_CREATED]: TakaroEventShopListingCreated,
+  [TakaroEvents.SHOP_LISTING_UPDATED]: TakaroEventShopListingUpdated,
+  [TakaroEvents.SHOP_LISTING_DELETED]: TakaroEventShopListingDeleted,
+  [TakaroEvents.SHOP_ORDER_CREATED]: TakaroEventShopOrderCreated,
+  [TakaroEvents.SHOP_ORDER_STATUS_CHANGED]: TakaroEventShopOrderStatusChanged,
+  [TakaroEvents.SHOP_ORDER_DELIVERY_FAILED]: TakaroEventShopOrderDeliveryFailed,
+  [TakaroEvents.PLAYER_LINKED]: TakaroEventPlayerLinked,
+  [TakaroEvents.GAMESERVER_CREATED]: TakaroEventGameserverCreated,
+  [TakaroEvents.GAMESERVER_UPDATED]: TakaroEventGameserverUpdated,
+  [TakaroEvents.GAMESERVER_DELETED]: TakaroEventGameserverDeleted,
+  [TakaroEvents.PLAYER_BANNED]: TakaroEventPlayerBanned,
+  [TakaroEvents.PLAYER_UNBANNED]: TakaroEventPlayerUnbanned,
+  [TakaroEvents.PLAYER_DELETED]: TakaroEventPlayerDeleted,
+} as const;

package/src/main.ts

@@ -0,0 +1,47 @@
+import { ModuleTransferDTO } from './BuiltinModule.js';
+import { ChatBridge } from './modules/chatBridge/index.js';
+import { DailyRewards } from './modules/dailyRewards/index.js';
+import { EconomyUtils } from './modules/economyUtils/index.js';
+import { GeoBlock } from './modules/geoBlock/index.js';
+import { Gimme } from './modules/gimme/index.js';
+import { HighPingKicker } from './modules/highPingKicker/index.js';
+import { Lottery } from './modules/lottery/index.js';
+import { PlayerOnboarding } from './modules/playerOnboarding/index.js';
+import { ServerMessages } from './modules/serverMessages/index.js';
+import { Teleports } from './modules/teleports/index.js';
+import { TimedShutdown } from './modules/timedShutdown/index.js';
+import { Utils } from './modules/utils/index.js';
+
+export {
+  ModuleTransferDTO,
+  ModuleTransferVersionDTO,
+  ICommand,
+  ICommandArgument,
+  ICronJob,
+  IHook,
+  IFunction,
+} from './BuiltinModule.js';
+export * from './dto/index.js';
+
+let cached: Array<ModuleTransferDTO<unknown>> | null = null;
+
+export function getModules(): Array<ModuleTransferDTO<unknown>> {
+  if (!cached) {
+    cached = [
+      new Utils(),
+      new Teleports(),
+      new PlayerOnboarding(),
+      new ServerMessages(),
+      new ChatBridge(),
+      new Gimme(),
+      new HighPingKicker(),
+      new EconomyUtils(),
+      new Lottery(),
+      new GeoBlock(),
+      new TimedShutdown(),
+      new DailyRewards(),
+    ];
+  }
+
+  return cached;
+}

package/src/modules/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-console": ["off"]
+  }
+}

package/src/modules/chatBridge/hooks/DiscordToGame.js

@@ -0,0 +1,18 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  try {
+    if (data.eventData.author.isBot) return;
+
+    await takaro.gameserver.gameServerControllerSendMessage(data.gameServerId, {
+      message: `[D] ${data.eventData.author.displayName}:  ${data.eventData.msg}`,
+    });
+  } catch (error) {
+    console.error(error);
+    await takaro.discordControllerSendMessage(data.discordChannelId, {
+      message: 'Failed to forward your message to the game. Please try again later.',
+    });
+  }
+}
+
+await main();

package/src/modules/chatBridge/hooks/GameToDiscord.js

@@ -0,0 +1,18 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const onlyGlobal = data.module.userConfig.onlyGlobalChat;
+
+  if (onlyGlobal && data.eventData.channel !== 'global') return;
+
+  const discordChannel = data.module.systemConfig.hooks['DiscordToGame'].discordChannelId;
+
+  const sender = data.player ? data.player.name : 'Non-player';
+  const message = `**${sender}**: ${data.eventData.msg}`;
+
+  await takaro.discord.discordControllerSendMessage(discordChannel, {
+    message: message,
+  });
+}
+
+await main();

package/src/modules/chatBridge/hooks/PlayerConnected.js

@@ -0,0 +1,11 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const discordChannel = data.module.systemConfig.hooks['DiscordToGame'].discordChannelId;
+
+  await takaro.discord.discordControllerSendMessage(discordChannel, {
+    message: `[⚡ Connected]: ${data.player.name}`,
+  });
+}
+
+await main();

package/src/modules/chatBridge/hooks/PlayerDisconnected.js

@@ -0,0 +1,11 @@
+import { takaro, data } from '@takaro/helpers';
+
+async function main() {
+  const discordChannel = data.module.systemConfig.hooks['DiscordToGame'].discordChannelId;
+
+  await takaro.discord.discordControllerSendMessage(discordChannel, {
+    message: `[👋 Disconnected]: ${data.player.name}`,
+  });
+}
+
+await main();

package/src/modules/chatBridge/index.ts

@@ -0,0 +1,64 @@
+import { ModuleTransferDTO, IHook, ModuleTransferVersionDTO } from '../../BuiltinModule.js';
+import { HookEvents } from '../../dto/index.js';
+
+export class ChatBridge extends ModuleTransferDTO<ChatBridge> {
+  constructor() {
+    super();
+    this.name = 'chatBridge';
+    this.author = 'Takaro';
+    this.supportedGames = ['all'];
+    this.versions = [
+      new ModuleTransferVersionDTO({
+        tag: '0.0.1',
+        description: 'Connect chat to other services like Discord.',
+        configSchema: JSON.stringify({
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          type: 'object',
+          properties: {
+            sendPlayerConnected: {
+              title: 'Send player connected',
+              type: 'boolean',
+              description: 'Send a message when a player connects.',
+              default: true,
+            },
+            sendPlayerDisconnected: {
+              title: 'Send player disconnected',
+              type: 'boolean',
+              description: 'Send a message when a player disconnects.',
+              default: true,
+            },
+            onlyGlobalChat: {
+              title: 'Only global chat',
+              type: 'boolean',
+              default: true,
+              description: 'Only relay messages from global chat. (no team chat or private messages)',
+            },
+          },
+          additionalProperties: false,
+        }),
+        hooks: [
+          new IHook({
+            eventType: HookEvents.DISCORD_MESSAGE,
+            name: 'DiscordToGame',
+            function: this.loadFn('hooks', 'DiscordToGame'),
+          }),
+          new IHook({
+            eventType: HookEvents.CHAT_MESSAGE,
+            name: 'GameToDiscord',
+            function: this.loadFn('hooks', 'GameToDiscord'),
+          }),
+          new IHook({
+            eventType: HookEvents.PLAYER_CONNECTED,
+            name: 'PlayerConnected',
+            function: this.loadFn('hooks', 'PlayerConnected'),
+          }),
+          new IHook({
+            eventType: HookEvents.PLAYER_DISCONNECTED,
+            name: 'PlayerDisconnected',
+            function: this.loadFn('hooks', 'PlayerDisconnected'),
+          }),
+        ],
+      }),
+    ];
+  }
+}