mezon-js 2.8.67 → 2.8.68

package/client.ts

@@ -96,6 +96,10 @@ import {
   ApiAppList,
   ApiApp,
   MezonUpdateAppBody,
+  ApiSystemMessagesList,
+  ApiSystemMessage,
+  ApiSystemMessageRequest,
+  MezonUpdateSystemMessageBody,
 } from "./api.gen";
 
 import { Session } from "./session";
@@ -117,13 +121,13 @@ export enum ChannelType {
   CHANNEL_TYPE_ANNOUNCEMENT = 6,
   CHANNEL_TYPE_THREAD = 7,
 }
-export enum ChannelStreamMode {  
+export enum ChannelStreamMode {
   STREAM_MODE_CHANNEL = 2,
   STREAM_MODE_GROUP = 3,
   STREAM_MODE_DM = 4,
 }
 
-export enum NotificationType {  
+export enum NotificationType {
   ALL_MESSAGE = 1,
   MENTION_MESSAGE = 2,
   NOTHING_MESSAGE = 3,
@@ -444,9 +448,7 @@ export interface ApiUpdateRoleRequest {
   role_icon: string | undefined;
   description: string | undefined;
   display_online: number | undefined;
-  allow_mention:
-    | number
-    | undefined;
+  allow_mention: number | undefined;
   /** The users to add. */
   add_user_ids: string[];
   /** The permissions to add. */
@@ -456,12 +458,11 @@ export interface ApiUpdateRoleRequest {
   /** The permissions to remove. */
   remove_permission_ids: string[];
   //
-  clan_id: string
+  clan_id: string;
 }
 
 /** A client for Mezon server. */
 export class Client {
-
   /** The expired timespan used to check session lifetime. */
   public expiredTimespanMs = DEFAULT_EXPIRED_TIMESPAN_MS;
 
@@ -469,116 +470,224 @@ export class Client {
   private readonly apiClient: MezonApi;
 
   constructor(
-      readonly serverkey = DEFAULT_SERVER_KEY,
-      readonly host = DEFAULT_HOST,
-      readonly port = DEFAULT_PORT,
-      readonly useSSL = false,
-      readonly timeout = DEFAULT_TIMEOUT_MS,
-      readonly autoRefreshSession = true) {
-    const scheme = (useSSL) ? "https://" : "http://";
+    readonly serverkey = DEFAULT_SERVER_KEY,
+    readonly host = DEFAULT_HOST,
+    readonly port = DEFAULT_PORT,
+    readonly useSSL = false,
+    readonly timeout = DEFAULT_TIMEOUT_MS,
+    readonly autoRefreshSession = true
+  ) {
+    const scheme = useSSL ? "https://" : "http://";
     const basePath = `${scheme}${host}:${port}`;
 
     this.apiClient = new MezonApi(serverkey, basePath, timeout);
   }
 
   /** Add users to a channel, or accept their join requests. */
-  async addChannelUsers(session: Session, channelId: string, ids?: Array<string>): Promise<boolean> {
-
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async addChannelUsers(
+    session: Session,
+    channelId: string,
+    ids?: Array<string>
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.addChannelUsers(session.token, channelId, ids).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .addChannelUsers(session.token, channelId, ids)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add friends by ID or username to a user's account. */
-  async addFriends(session: Session, ids?: Array<string>, usernames?: Array<string>): Promise<boolean> {
-
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async addFriends(
+    session: Session,
+    ids?: Array<string>,
+    usernames?: Array<string>
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.addFriends(session.token, ids, usernames).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .addFriends(session.token, ids, usernames)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Authenticate a user with an Apple ID against the server. */
-  async authenticateApple(token: string, create?: boolean, username?: string, vars: Record<string, string> = {}, options: any = {}) {
-
+  async authenticateApple(
+    token: string,
+    create?: boolean,
+    username?: string,
+    vars: Record<string, string> = {},
+    options: any = {}
+  ) {
     const request = {
-      "token": token,
-      "vars": vars
+      token: token,
+      vars: vars,
     };
 
-    return this.apiClient.authenticateApple(this.serverkey, "", request, create, username, options).then((apiSession : ApiSession) => {
-      return new Session(apiSession.token || "", apiSession.refresh_token || "", apiSession.created || false);
-    });
+    return this.apiClient
+      .authenticateApple(this.serverkey, "", request, create, username, options)
+      .then((apiSession: ApiSession) => {
+        return new Session(
+          apiSession.token || "",
+          apiSession.refresh_token || "",
+          apiSession.created || false
+        );
+      });
   }
 
   /** Authenticate a user with a custom id against the server. */
-  authenticateCustom(id: string, create?: boolean, username?: string, vars: Record<string, string> = {}, options: any = {}): Promise<Session> {
+  authenticateCustom(
+    id: string,
+    create?: boolean,
+    username?: string,
+    vars: Record<string, string> = {},
+    options: any = {}
+  ): Promise<Session> {
     const request = {
-      "id": id,
-      "vars": vars
+      id: id,
+      vars: vars,
     };
-    return this.apiClient.authenticateCustom(this.serverkey, "", request, create, username, options).then((apiSession : ApiSession) => {
-      return new Session(apiSession.token || "", apiSession.refresh_token || "", apiSession.created || false);
-    });
+    return this.apiClient
+      .authenticateCustom(
+        this.serverkey,
+        "",
+        request,
+        create,
+        username,
+        options
+      )
+      .then((apiSession: ApiSession) => {
+        return new Session(
+          apiSession.token || "",
+          apiSession.refresh_token || "",
+          apiSession.created || false
+        );
+      });
   }
 
   /** Authenticate a user with a device id against the server. */
-  authenticateDevice(id : string, create?: boolean, username?: string, vars? : Record<string, string>): Promise<Session> {
+  authenticateDevice(
+    id: string,
+    create?: boolean,
+    username?: string,
+    vars?: Record<string, string>
+  ): Promise<Session> {
     const request = {
-      "id": id,
-      "vars": vars
+      id: id,
+      vars: vars,
     };
 
-    return this.apiClient.authenticateDevice(this.serverkey, "", request, create, username).then((apiSession : ApiSession) => {
-      return new Session(apiSession.token || "", apiSession.refresh_token || "", apiSession.created || false);
-    });
+    return this.apiClient
+      .authenticateDevice(this.serverkey, "", request, create, username)
+      .then((apiSession: ApiSession) => {
+        return new Session(
+          apiSession.token || "",
+          apiSession.refresh_token || "",
+          apiSession.created || false
+        );
+      });
   }
 
   /** Authenticate a user with an email+password against the server. */
-  authenticateEmail(email: string, password: string, username?: string, vars?: Record<string,string>): Promise<Session> {
+  authenticateEmail(
+    email: string,
+    password: string,
+    username?: string,
+    vars?: Record<string, string>
+  ): Promise<Session> {
     const request = {
-      "email": email,
-      "password": password,
-      "vars": vars
+      email: email,
+      password: password,
+      vars: vars,
     };
 
-    return this.apiClient.authenticateEmail(this.serverkey, "", request, username).then((apiSession : ApiSession) => {
-      return new Session(apiSession.token || "", apiSession.refresh_token || "", apiSession.created || false);
-    });
+    return this.apiClient
+      .authenticateEmail(this.serverkey, "", request, username)
+      .then((apiSession: ApiSession) => {
+        return new Session(
+          apiSession.token || "",
+          apiSession.refresh_token || "",
+          apiSession.created || false
+        );
+      });
   }
 
   /** Authenticate a user with a Facebook Instant Game token against the server. */
-  authenticateFacebookInstantGame(signedPlayerInfo: string, create?: boolean, username?: string, vars?: Record<string, string>, options: any = {}): Promise<Session> {
+  authenticateFacebookInstantGame(
+    signedPlayerInfo: string,
+    create?: boolean,
+    username?: string,
+    vars?: Record<string, string>,
+    options: any = {}
+  ): Promise<Session> {
     const request = {
-      "signed_player_info": signedPlayerInfo,
-      "vars": vars
+      signed_player_info: signedPlayerInfo,
+      vars: vars,
     };
 
-    return this.apiClient.authenticateFacebookInstantGame(this.serverkey, "",
-      {signed_player_info: request.signed_player_info, vars: request.vars}, create, username, options).then((apiSession : ApiSession) => {
-        return new Session(apiSession.token || "", apiSession.refresh_token || "", apiSession.created || false);
+    return this.apiClient
+      .authenticateFacebookInstantGame(
+        this.serverkey,
+        "",
+        { signed_player_info: request.signed_player_info, vars: request.vars },
+        create,
+        username,
+        options
+      )
+      .then((apiSession: ApiSession) => {
+        return new Session(
+          apiSession.token || "",
+          apiSession.refresh_token || "",
+          apiSession.created || false
+        );
       });
   }
 
   /** Authenticate a user with a Facebook OAuth token against the server. */
-  authenticateFacebook(token : string, create?: boolean, username?: string, sync?: boolean, vars? : Record<string, string>, options: any = {}): Promise<Session> {
+  authenticateFacebook(
+    token: string,
+    create?: boolean,
+    username?: string,
+    sync?: boolean,
+    vars?: Record<string, string>,
+    options: any = {}
+  ): Promise<Session> {
     const request = {
-      "token": token,
-      "vars": vars
+      token: token,
+      vars: vars,
     };
 
-    return this.apiClient.authenticateFacebook(this.serverkey, "", request, create, username, sync, options).then((apiSession : ApiSession) => {
-      return new Session(apiSession.token || "", apiSession.refresh_token || "", apiSession.created || false);
-    });
+    return this.apiClient
+      .authenticateFacebook(
+        this.serverkey,
+        "",
+        request,
+        create,
+        username,
+        sync,
+        options
+      )
+      .then((apiSession: ApiSession) => {
+        return new Session(
+          apiSession.token || "",
+          apiSession.refresh_token || "",
+          apiSession.created || false
+        );
+      });
   }
 
   /** Authenticate a user with Google against the server. */
@@ -621,7 +730,7 @@ export class Client {
     username?: string,
     create?: boolean,
     vars?: Record<string, string>,
-    options: any = {},
+    options: any = {}
   ): Promise<Session> {
     const request: ApiAccountGameCenter = {
       bundle_id: bundleId,
@@ -650,1626 +759,2674 @@ export class Client {
   }
 
   /** Authenticate a user with Steam against the server. */
-  async authenticateSteam(token : string, create?: boolean, username?: string, sync?: boolean, vars? : Record<string, string>) : Promise<Session> {
+  async authenticateSteam(
+    token: string,
+    create?: boolean,
+    username?: string,
+    sync?: boolean,
+    vars?: Record<string, string>
+  ): Promise<Session> {
     const request = {
-      "token": token,
-      "vars": vars,
-      "sync": sync
+      token: token,
+      vars: vars,
+      sync: sync,
     };
 
-    return this.apiClient.authenticateSteam(this.serverkey, "", request, create, username).then((apiSession : ApiSession) => {
-      return new Session(apiSession.token || "", apiSession.refresh_token || "", apiSession.created || false);
-    });
+    return this.apiClient
+      .authenticateSteam(this.serverkey, "", request, create, username)
+      .then((apiSession: ApiSession) => {
+        return new Session(
+          apiSession.token || "",
+          apiSession.refresh_token || "",
+          apiSession.created || false
+        );
+      });
   }
 
   /** Block one or more users by ID or username. */
-  async blockFriends(session: Session, ids?: Array<string>, usernames?: Array<string>): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async blockFriends(
+    session: Session,
+    ids?: Array<string>,
+    usernames?: Array<string>
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.blockFriends(session.token, ids, usernames).then((response: any) => {
-      return Promise.resolve(response != undefined);
-    });
+    return this.apiClient
+      .blockFriends(session.token, ids, usernames)
+      .then((response: any) => {
+        return Promise.resolve(response != undefined);
+      });
   }
 
   /** Create a new group with the current user as the creator and superadmin. */
-  async uploadAttachmentFile(session: Session, request: ApiUploadAttachmentRequest): Promise<ApiUploadAttachment> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async uploadAttachmentFile(
+    session: Session,
+    request: ApiUploadAttachmentRequest
+  ): Promise<ApiUploadAttachment> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
     return this.apiClient.uploadAttachmentFile(session.token, request);
   }
 
   /** Create a channel within clan */
-  async createChannelDesc(session: Session, request: ApiCreateChannelDescRequest): Promise<ApiChannelDescription> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async createChannelDesc(
+    session: Session,
+    request: ApiCreateChannelDescRequest
+  ): Promise<ApiChannelDescription> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.createChannelDesc(session.token, request).then((response: ApiChannelDescription) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .createChannelDesc(session.token, request)
+      .then((response: ApiChannelDescription) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** Create a clan */
-  async createClanDesc(session: Session, request: ApiCreateClanDescRequest): Promise<ApiClanDesc> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async createClanDesc(
+    session: Session,
+    request: ApiCreateClanDescRequest
+  ): Promise<ApiClanDesc> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.createClanDesc(session.token, request).then((response: ApiClanDesc) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .createClanDesc(session.token, request)
+      .then((response: ApiClanDesc) => {
+        return Promise.resolve(response);
+      });
   }
 
   /**  */
-  async createCategoryDesc(session: Session, request: ApiCreateCategoryDescRequest): Promise<ApiCategoryDesc> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async createCategoryDesc(
+    session: Session,
+    request: ApiCreateCategoryDescRequest
+  ): Promise<ApiCategoryDesc> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.createCategoryDesc(session.token, request).then((response: ApiCategoryDesc) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .createCategoryDesc(session.token, request)
+      .then((response: ApiCategoryDesc) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** Create a new role for clan. */
-  async createRole(session: Session, request: ApiCreateRoleRequest): Promise<ApiRole> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async createRole(
+    session: Session,
+    request: ApiCreateRoleRequest
+  ): Promise<ApiRole> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.createRole(session.token, request).then((response: ApiRole) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .createRole(session.token, request)
+      .then((response: ApiRole) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** Create a new event for clan. */
-  async createEvent(session: Session, request: ApiCreateEventRequest): Promise<ApiEventManagement> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async createEvent(
+    session: Session,
+    request: ApiCreateEventRequest
+  ): Promise<ApiEventManagement> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.createEvent(session.token, request).then((response: ApiEventManagement) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .createEvent(session.token, request)
+      .then((response: ApiEventManagement) => {
+        return Promise.resolve(response);
+      });
   }
 
-  
   /** add role for channel. */
-  async addRolesChannelDesc(session: Session, request: ApiAddRoleChannelDescRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async addRolesChannelDesc(
+    session: Session,
+    request: ApiAddRoleChannelDescRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.addRolesChannelDesc(session.token, request).then((response: ApiRole) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .addRolesChannelDesc(session.token, request)
+      .then((response: ApiRole) => {
+        return response !== undefined;
+      });
   }
 
-   /** Update action role when delete role */
-   async deleteRoleChannelDesc(session: Session, request:ApiDeleteRoleRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  /** Update action role when delete role */
+  async deleteRoleChannelDesc(
+    session: Session,
+    request: ApiDeleteRoleRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteRoleChannelDesc(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteRoleChannelDesc(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   async deleteApp(session: Session, appId: string): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteApp(session.token, appId).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteApp(session.token, appId)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** A socket created with the client's configuration. */
-  createSocket(useSSL = false, verbose: boolean = false, adapter : WebSocketAdapter = new WebSocketAdapterText(), sendTimeoutMs : number = DefaultSocket.DefaultSendTimeoutMs): Socket {
-    return new DefaultSocket(this.host, this.port, useSSL, verbose, adapter, sendTimeoutMs);
+  createSocket(
+    useSSL = false,
+    verbose: boolean = false,
+    adapter: WebSocketAdapter = new WebSocketAdapterText(),
+    sendTimeoutMs: number = DefaultSocket.DefaultSendTimeoutMs
+  ): Socket {
+    return new DefaultSocket(
+      this.host,
+      this.port,
+      useSSL,
+      verbose,
+      adapter,
+      sendTimeoutMs
+    );
   }
 
   /** Delete one or more users by ID or username. */
-  async deleteFriends(session: Session, ids?: Array<string>, usernames?: Array<string>): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async deleteFriends(
+    session: Session,
+    ids?: Array<string>,
+    usernames?: Array<string>
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteFriends(session.token, ids, usernames).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteFriends(session.token, ids, usernames)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Delete a channel by ID. */
-  async deleteChannelDesc(session: Session, channelId: string): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async deleteChannelDesc(
+    session: Session,
+    channelId: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteChannelDesc(session.token, channelId).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteChannelDesc(session.token, channelId)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Delete a clan desc by ID. */
   async deleteClanDesc(session: Session, clanDescId: string): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteClanDesc(session.token, clanDescId).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteClanDesc(session.token, clanDescId)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Delete a category by ID. */
-  async deleteCategoryDesc(session: Session, creatorId: string): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async deleteCategoryDesc(
+    session: Session,
+    creatorId: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteCategoryDesc(session.token, creatorId).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteCategoryDesc(session.token, creatorId)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Delete one or more notifications */
-  async deleteNotifications(session: Session, ids?: Array<string>): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async deleteNotifications(
+    session: Session,
+    ids?: Array<string>
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteNotifications(session.token, ids).then((response: any) => {
-      return Promise.resolve(response != undefined);
-    });
+    return this.apiClient
+      .deleteNotifications(session.token, ids)
+      .then((response: any) => {
+        return Promise.resolve(response != undefined);
+      });
   }
 
   /** Delete a role by ID. */
-  async deleteRole(session: Session, roleId: string, clanId: string): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async deleteRole(
+    session: Session,
+    roleId: string,
+    clanId: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteRole(session.token, roleId, "", clanId).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteRole(session.token, roleId, "", clanId)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Delete a event by ID. */
-  async deleteEvent(session: Session, eventId: string, clanId: string): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async deleteEvent(
+    session: Session,
+    eventId: string,
+    clanId: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.deleteEvent(session.token, eventId, clanId).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .deleteEvent(session.token, eventId, clanId)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** update user a event by ID. */
-  async updateEventUser(session: Session, request: ApiDeleteEventRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateEventUser(
+    session: Session,
+    request: ApiDeleteEventRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateEventUser(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateEventUser(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Submit an event for processing in the server's registered runtime custom events handler. */
   async emitEvent(session: Session, request: ApiEvent): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.event(session.token, request).then((response: any) => {
-      return Promise.resolve(response != undefined);
-    });
+    return this.apiClient
+      .event(session.token, request)
+      .then((response: any) => {
+        return Promise.resolve(response != undefined);
+      });
   }
 
   /** Fetch the current user's account. */
   async getAccount(session: Session): Promise<ApiAccount> {
-
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
     return this.apiClient.getAccount(session.token);
   }
 
   /** Import Facebook friends and add them to a user's account. */
-  async importFacebookFriends(session: Session, request: ApiAccountFacebook): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async importFacebookFriends(
+    session: Session,
+    request: ApiAccountFacebook
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.importFacebookFriends(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .importFacebookFriends(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-    /** Import Steam friends and add them to a user's account. */
-  async importSteamFriends(session: Session, request: ApiAccountSteam, reset: boolean): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  /** Import Steam friends and add them to a user's account. */
+  async importSteamFriends(
+    session: Session,
+    request: ApiAccountSteam,
+    reset: boolean
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.importSteamFriends(session.token, request, reset).then((response: any) => {
+    return this.apiClient
+      .importSteamFriends(session.token, request, reset)
+      .then((response: any) => {
         return response !== undefined;
-    });
+      });
   }
 
   /** Fetch zero or more users by ID and/or username. */
-  async getUsers(session: Session, ids?: Array<string>, usernames?: Array<string>, facebookIds?: Array<string>): Promise<Users> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async getUsers(
+    session: Session,
+    ids?: Array<string>,
+    usernames?: Array<string>,
+    facebookIds?: Array<string>
+  ): Promise<Users> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.getUsers(session.token, ids, usernames, facebookIds).then((response: ApiUsers) => {
-      var result: Users = {
-        users: []
-      };
+    return this.apiClient
+      .getUsers(session.token, ids, usernames, facebookIds)
+      .then((response: ApiUsers) => {
+        var result: Users = {
+          users: [],
+        };
+
+        if (response.users == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.users == null) {
+        response.users!.forEach((u) => {
+          result.users!.push({
+            avatar_url: u.avatar_url,
+            create_time: u.create_time,
+            display_name: u.display_name,
+            edge_count: u.edge_count ? Number(u.edge_count) : 0,
+            facebook_id: u.facebook_id,
+            gamecenter_id: u.gamecenter_id,
+            google_id: u.google_id,
+            id: u.id,
+            lang_tag: u.lang_tag,
+            location: u.location,
+            online: u.online,
+            steam_id: u.steam_id,
+            timezone: u.timezone,
+            update_time: u.update_time,
+            username: u.username,
+            metadata: u.metadata ? JSON.parse(u.metadata) : undefined,
+          });
+        });
         return Promise.resolve(result);
-      }
-
-      response.users!.forEach(u => {
-        result.users!.push({
-          avatar_url: u.avatar_url,
-          create_time: u.create_time,
-          display_name: u.display_name,
-          edge_count: u.edge_count ? Number(u.edge_count) : 0,
-          facebook_id: u.facebook_id,
-          gamecenter_id: u.gamecenter_id,
-          google_id: u.google_id,
-          id: u.id,
-          lang_tag: u.lang_tag,
-          location: u.location,
-          online: u.online,
-          steam_id: u.steam_id,
-          timezone: u.timezone,
-          update_time: u.update_time,
-          username: u.username,
-          metadata: u.metadata ? JSON.parse(u.metadata) : undefined
-        })
-      });
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** Kick a set of users from a clan. */
-  async removeClanUsers(session: Session, clanId: string, ids?: Array<string>): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async removeClanUsers(
+    session: Session,
+    clanId: string,
+    ids?: Array<string>
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.removeClanUsers(session.token, clanId, ids).then((response: any) => {
-      return Promise.resolve(response != undefined);
-    });
+    return this.apiClient
+      .removeClanUsers(session.token, clanId, ids)
+      .then((response: any) => {
+        return Promise.resolve(response != undefined);
+      });
   }
 
   /** Kick users from a channel, or decline their join requests. */
-  async removeChannelUsers(session: Session, channelId: string, ids?: Array<string>): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async removeChannelUsers(
+    session: Session,
+    channelId: string,
+    ids?: Array<string>
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.removeChannelUsers(session.token, channelId, ids).then((response: any) => {
-      return Promise.resolve(response != undefined);
-    });
+    return this.apiClient
+      .removeChannelUsers(session.token, channelId, ids)
+      .then((response: any) => {
+        return Promise.resolve(response != undefined);
+      });
   }
 
   /** List a channel's message history. */
-  async listChannelMessages(session: Session, channelId: string, messageId?: string, direction?: number, limit?: number): Promise<ChannelMessageList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listChannelMessages(
+    session: Session,
+    channelId: string,
+    messageId?: string,
+    direction?: number,
+    limit?: number
+  ): Promise<ChannelMessageList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listChannelMessages(session.token, channelId, messageId, direction, limit).then((response: ApiChannelMessageList) => {
-      var result: ChannelMessageList = {
-        messages: [],
-        last_seen_message: response.last_seen_message,
-        last_sent_message: response.last_sent_message
-      };
-
-      if (response.messages == null) {
-        return Promise.resolve(result);
-      }
-      response.messages!.forEach(m => {
-        var content, reactions, mentions, attachments, references;
-        try {                        
-          content = JSON.parse(m.content);
-        } catch(e) {
-          //console.log("error parse content", e);
-        }
-        try {
-          reactions = JSON.parse(m.reactions || '[]');
-        } catch(e) {
-          //console.log("error parse reactions", e);
-        }
-        try {
-          mentions = JSON.parse(m.mentions || '[]');
-        } catch(e) {
-          //console.log("error parse mentions", e);
-        }
-        try {
-          attachments = JSON.parse(m.attachments || '[]');
-        } catch(e) {
-          //console.log("error parse attachments", e);
+    return this.apiClient
+      .listChannelMessages(
+        session.token,
+        channelId,
+        messageId,
+        direction,
+        limit
+      )
+      .then((response: ApiChannelMessageList) => {
+        var result: ChannelMessageList = {
+          messages: [],
+          last_seen_message: response.last_seen_message,
+          last_sent_message: response.last_sent_message,
+        };
+
+        if (response.messages == null) {
+          return Promise.resolve(result);
         }
-        try {  
-          references = JSON.parse(m.references || '[]');
-        } catch(e) {
-          //console.log("error parse references", e);
-        }
-        result.messages!.push({
-          channel_id: m.channel_id,
-          code: m.code ? Number(m.code) : 0,
-          create_time: m.create_time || '',
-          id: m.message_id,
-          sender_id: m.sender_id,
-          update_time: m.update_time,
-          username: m.username,
-          display_name: m.display_name,
-          avatar: m.avatar,
-          content: content,
-          channel_label: m.channel_label,
-          clan_logo: m.clan_logo,
-          category_name: m.category_name,
-          clan_nick: m.clan_nick,
-          clan_avatar: m.clan_avatar,
-          attachments: attachments,
-          mentions: mentions,
-          reactions: reactions,
-          references: references,
-          clan_id: m.clan_id,
-          create_time_seconds: m.create_time_seconds,
-          update_time_seconds: m.update_time_seconds,
-        })
-      });
-      return Promise.resolve(result);
-    });
+        response.messages!.forEach((m) => {
+          var content, reactions, mentions, attachments, references;
+          try {
+            content = JSON.parse(m.content);
+          } catch (e) {
+            //console.log("error parse content", e);
+          }
+          try {
+            reactions = JSON.parse(m.reactions || "[]");
+          } catch (e) {
+            //console.log("error parse reactions", e);
+          }
+          try {
+            mentions = JSON.parse(m.mentions || "[]");
+          } catch (e) {
+            //console.log("error parse mentions", e);
+          }
+          try {
+            attachments = JSON.parse(m.attachments || "[]");
+          } catch (e) {
+            //console.log("error parse attachments", e);
+          }
+          try {
+            references = JSON.parse(m.references || "[]");
+          } catch (e) {
+            //console.log("error parse references", e);
+          }
+          result.messages!.push({
+            channel_id: m.channel_id,
+            code: m.code ? Number(m.code) : 0,
+            create_time: m.create_time || "",
+            id: m.message_id,
+            sender_id: m.sender_id,
+            update_time: m.update_time,
+            username: m.username,
+            display_name: m.display_name,
+            avatar: m.avatar,
+            content: content,
+            channel_label: m.channel_label,
+            clan_logo: m.clan_logo,
+            category_name: m.category_name,
+            clan_nick: m.clan_nick,
+            clan_avatar: m.clan_avatar,
+            attachments: attachments,
+            mentions: mentions,
+            reactions: reactions,
+            references: references,
+            clan_id: m.clan_id,
+            create_time_seconds: m.create_time_seconds,
+            update_time_seconds: m.update_time_seconds,
+          });
+        });
+        return Promise.resolve(result);
+      });
   }
 
   /** List a channel's users. */
-  async listChannelVoiceUsers(session: Session, clanId: string, channelId: string, channelType: number, state?: number, limit?: number, cursor?: string): Promise<ApiVoiceChannelUserList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listChannelVoiceUsers(
+    session: Session,
+    clanId: string,
+    channelId: string,
+    channelType: number,
+    state?: number,
+    limit?: number,
+    cursor?: string
+  ): Promise<ApiVoiceChannelUserList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listChannelVoiceUsers(session.token, clanId, channelId, channelType, limit, state, cursor).then((response: ApiVoiceChannelUserList) => {
-      var result: ApiVoiceChannelUserList = {
-        voice_channel_users: []
-      };
+    return this.apiClient
+      .listChannelVoiceUsers(
+        session.token,
+        clanId,
+        channelId,
+        channelType,
+        limit,
+        state,
+        cursor
+      )
+      .then((response: ApiVoiceChannelUserList) => {
+        var result: ApiVoiceChannelUserList = {
+          voice_channel_users: [],
+        };
+
+        if (response.voice_channel_users == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.voice_channel_users == null) {
+        response.voice_channel_users!.forEach((gu) => {
+          result.voice_channel_users!.push({
+            id: gu.id,
+            channel_id: gu.channel_id,
+            user_id: gu.user_id,
+            participant: gu.participant,
+          });
+        });
         return Promise.resolve(result);
-      }
-
-      response.voice_channel_users!.forEach(gu => {        
-        result.voice_channel_users!.push({
-          id: gu.id,
-          channel_id: gu.channel_id,
-          user_id: gu.user_id,
-          participant: gu.participant
-        })
       });
-      return Promise.resolve(result);
-    });
   }
 
   /** List a channel's users. */
-  async listChannelUsers(session: Session, clanId: string, channelId: string, channelType: number, state?: number, limit?: number, cursor?: string): Promise<ApiChannelUserList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listChannelUsers(
+    session: Session,
+    clanId: string,
+    channelId: string,
+    channelType: number,
+    state?: number,
+    limit?: number,
+    cursor?: string
+  ): Promise<ApiChannelUserList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listChannelUsers(session.token, clanId, channelId, channelType, limit, state, cursor).then((response: ApiChannelUserList) => {
-      var result: ApiChannelUserList = {
-        channel_users: [],
-        cursor: response.cursor,
-        channel_id: response.channel_id
-      };
+    return this.apiClient
+      .listChannelUsers(
+        session.token,
+        clanId,
+        channelId,
+        channelType,
+        limit,
+        state,
+        cursor
+      )
+      .then((response: ApiChannelUserList) => {
+        var result: ApiChannelUserList = {
+          channel_users: [],
+          cursor: response.cursor,
+          channel_id: response.channel_id,
+        };
+
+        if (response.channel_users == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.channel_users == null) {
+        response.channel_users!.forEach((gu) => {
+          result.channel_users!.push({
+            user: {
+              avatar_url: gu.user!.avatar_url,
+              create_time: gu.user!.create_time,
+              display_name: gu.user!.display_name,
+              edge_count: gu.user!.edge_count ? Number(gu.user!.edge_count) : 0,
+              facebook_id: gu.user!.facebook_id,
+              gamecenter_id: gu.user!.gamecenter_id,
+              google_id: gu.user!.google_id,
+              id: gu.user!.id,
+              lang_tag: gu.user!.lang_tag,
+              location: gu.user!.location,
+              online: gu.user!.online,
+              steam_id: gu.user!.steam_id,
+              timezone: gu.user!.timezone,
+              update_time: gu.user!.update_time,
+              username: gu.user!.username,
+              about_me: gu.user?.about_me,
+              metadata: gu.user!.metadata
+                ? JSON.parse(gu.user!.metadata!)
+                : undefined,
+            },
+            role_id: gu!.role_id,
+            thread_id: gu.thread_id,
+            clan_avatar: gu.clan_avatar,
+            clan_nick: gu.clan_nick,
+            id: gu.id,
+            clan_id: gu.clan_id,
+          });
+        });
         return Promise.resolve(result);
-      }
-
-      response.channel_users!.forEach(gu => {
-        result.channel_users!.push({
-          user: {
-            avatar_url: gu.user!.avatar_url,
-            create_time: gu.user!.create_time,
-            display_name: gu.user!.display_name,
-            edge_count: gu.user!.edge_count ? Number(gu.user!.edge_count): 0,
-            facebook_id: gu.user!.facebook_id,
-            gamecenter_id: gu.user!.gamecenter_id,
-            google_id: gu.user!.google_id,
-            id: gu.user!.id,
-            lang_tag: gu.user!.lang_tag,
-            location: gu.user!.location,
-            online: gu.user!.online,
-            steam_id: gu.user!.steam_id,
-            timezone: gu.user!.timezone,
-            update_time: gu.user!.update_time,
-            username: gu.user!.username,
-            about_me: gu.user?.about_me,
-            metadata: gu.user!.metadata ? JSON.parse(gu.user!.metadata!) : undefined
-          },
-          role_id: gu!.role_id,
-          thread_id: gu.thread_id,
-          clan_avatar: gu.clan_avatar,
-          clan_nick: gu.clan_nick,
-          id: gu.id,
-          clan_id: gu.clan_id
-        })
-      });
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** List a channel's attachment. */
-  async listChannelAttachments(session: Session, clanId: string, channelId: string, fileType: string, state?: number, limit?: number, cursor?: string): Promise<ApiChannelAttachmentList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listChannelAttachments(
+    session: Session,
+    clanId: string,
+    channelId: string,
+    fileType: string,
+    state?: number,
+    limit?: number,
+    cursor?: string
+  ): Promise<ApiChannelAttachmentList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listChannelAttachment(session.token, clanId, channelId, fileType, limit, state, cursor).then((response: ApiChannelAttachmentList) => {
-      var result: ApiChannelAttachmentList = {
-        attachments: [],
-      };
+    return this.apiClient
+      .listChannelAttachment(
+        session.token,
+        clanId,
+        channelId,
+        fileType,
+        limit,
+        state,
+        cursor
+      )
+      .then((response: ApiChannelAttachmentList) => {
+        var result: ApiChannelAttachmentList = {
+          attachments: [],
+        };
+
+        if (response.attachments == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.attachments == null) {
+        response.attachments!.forEach((at) => {
+          result.attachments!.push({
+            filename: at.filename,
+            filesize: at.filesize,
+            filetype: at.filetype,
+            id: at.id,
+            uploader: at.uploader,
+            url: at.url,
+            create_time: at.create_time,
+          });
+        });
         return Promise.resolve(result);
-      }
-
-      response.attachments!.forEach(at => {
-        result.attachments!.push({
-          filename: at.filename,
-          filesize: at.filesize,
-          filetype: at.filetype,
-          id: at.id,
-          uploader: at.uploader,
-          url: at.url,
-          create_time: at.create_time
-        })
-      });
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** List a channel's users. */
-  async listClanUsers(session: Session, clanId: string): Promise<ApiClanUserList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listClanUsers(
+    session: Session,
+    clanId: string
+  ): Promise<ApiClanUserList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listClanUsers(session.token, clanId).then((response: ApiClanUserList) => {
-      var result: ApiClanUserList = {
-        clan_users: [],
-        cursor: response.cursor,
-        clan_id: response.clan_id
-      };
+    return this.apiClient
+      .listClanUsers(session.token, clanId)
+      .then((response: ApiClanUserList) => {
+        var result: ApiClanUserList = {
+          clan_users: [],
+          cursor: response.cursor,
+          clan_id: response.clan_id,
+        };
+
+        if (response.clan_users == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.clan_users == null) {
+        response.clan_users!.forEach((gu) => {
+          result.clan_users!.push({
+            user: {
+              avatar_url: gu.user!.avatar_url,
+              create_time: gu.user!.create_time,
+              display_name: gu.user!.display_name,
+              edge_count: gu.user!.edge_count ? Number(gu.user!.edge_count) : 0,
+              facebook_id: gu.user!.facebook_id,
+              gamecenter_id: gu.user!.gamecenter_id,
+              google_id: gu.user!.google_id,
+              id: gu.user!.id,
+              lang_tag: gu.user!.lang_tag,
+              location: gu.user!.location,
+              online: gu.user!.online,
+              steam_id: gu.user!.steam_id,
+              timezone: gu.user!.timezone,
+              update_time: gu.user!.update_time,
+              username: gu.user!.username,
+              metadata: gu.user!.metadata
+                ? JSON.parse(gu.user!.metadata!)
+                : undefined,
+            },
+            role_id: gu!.role_id,
+            clan_nick: gu!.clan_nick,
+            clan_avatar: gu!.clan_avatar,
+          });
+        });
         return Promise.resolve(result);
-      }
-
-      response.clan_users!.forEach(gu => {
-        result.clan_users!.push({
-          user: {
-            avatar_url: gu.user!.avatar_url,
-            create_time: gu.user!.create_time,
-            display_name: gu.user!.display_name,
-            edge_count: gu.user!.edge_count ? Number(gu.user!.edge_count): 0,
-            facebook_id: gu.user!.facebook_id,
-            gamecenter_id: gu.user!.gamecenter_id,
-            google_id: gu.user!.google_id,
-            id: gu.user!.id,
-            lang_tag: gu.user!.lang_tag,
-            location: gu.user!.location,
-            online: gu.user!.online,
-            steam_id: gu.user!.steam_id,
-            timezone: gu.user!.timezone,
-            update_time: gu.user!.update_time,
-            username: gu.user!.username,
-            metadata: gu.user!.metadata ? JSON.parse(gu.user!.metadata!) : undefined
-          },
-          role_id: gu!.role_id,
-          clan_nick: gu!.clan_nick,
-          clan_avatar: gu!.clan_avatar 
-        })
-      });
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** List channels. */
-  async listChannelDescs(session: Session, limit?: number, state?:number, cursor?: string, clanId?: string, channelType?:number): Promise<ApiChannelDescList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listChannelDescs(
+    session: Session,
+    limit?: number,
+    state?: number,
+    cursor?: string,
+    clanId?: string,
+    channelType?: number
+  ): Promise<ApiChannelDescList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listChannelDescs(session.token, limit, state, cursor, clanId, channelType).then((response: ApiChannelDescList) => {
-      var result: ApiChannelDescList = {
-        channeldesc: [],
-        next_cursor: response.next_cursor,
-        prev_cursor: response.prev_cursor,
-        cacheable_cursor: response.cacheable_cursor
-      };
+    return this.apiClient
+      .listChannelDescs(
+        session.token,
+        limit,
+        state,
+        cursor,
+        clanId,
+        channelType
+      )
+      .then((response: ApiChannelDescList) => {
+        var result: ApiChannelDescList = {
+          channeldesc: [],
+          next_cursor: response.next_cursor,
+          prev_cursor: response.prev_cursor,
+          cacheable_cursor: response.cacheable_cursor,
+        };
+
+        if (response.channeldesc == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.channeldesc == null) {
+        result.channeldesc = response.channeldesc;
         return Promise.resolve(result);
-      }
-      
-      result.channeldesc = response.channeldesc;
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** List clans */
-  async listClanDescs(session: Session, limit?: number, state?:number, cursor?: string): Promise<ApiClanDescList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listClanDescs(
+    session: Session,
+    limit?: number,
+    state?: number,
+    cursor?: string
+  ): Promise<ApiClanDescList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listClanDescs(session.token, limit, state, cursor).then((response: ApiClanDescList) => {
-      var result: ApiClanDescList = {
-        clandesc: [],
-      };
+    return this.apiClient
+      .listClanDescs(session.token, limit, state, cursor)
+      .then((response: ApiClanDescList) => {
+        var result: ApiClanDescList = {
+          clandesc: [],
+        };
+
+        if (response.clandesc == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.clandesc == null) {
+        result.clandesc = response.clandesc;
         return Promise.resolve(result);
-      }
-      
-      result.clandesc = response.clandesc;
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** List categories. */
-  async listCategoryDescs(session: Session, clanId:string, creatorId?:string, categoryName?:string): Promise<ApiCategoryDescList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listCategoryDescs(
+    session: Session,
+    clanId: string,
+    creatorId?: string,
+    categoryName?: string
+  ): Promise<ApiCategoryDescList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listCategoryDescs(session.token, clanId, creatorId, categoryName).then((response: ApiCategoryDescList) => {
-      var result: ApiCategoryDescList = {
-        categorydesc: [],
-      };
+    return this.apiClient
+      .listCategoryDescs(session.token, clanId, creatorId, categoryName)
+      .then((response: ApiCategoryDescList) => {
+        var result: ApiCategoryDescList = {
+          categorydesc: [],
+        };
 
-      if (response.categorydesc == null) {
+        if (response.categorydesc == null) {
+          return Promise.resolve(result);
+        }
+
+        result.categorydesc = response.categorydesc;
         return Promise.resolve(result);
-      }
-      
-      result.categorydesc = response.categorydesc;
-      return Promise.resolve(result);
-    });
+      });
   }
 
-   /** List event */
-   async listEvents(session: Session, clanId?:string): Promise<ApiEventList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  /** List event */
+  async listEvents(session: Session, clanId?: string): Promise<ApiEventList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listEvents(session.token, clanId).then((response: ApiEventList) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .listEvents(session.token, clanId)
+      .then((response: ApiEventList) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** List permission */
   async getListPermission(session: Session): Promise<ApiPermissionList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.getListPermission(session.token).then((response: ApiPermissionList) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .getListPermission(session.token)
+      .then((response: ApiPermissionList) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** List user roles */
-  async listRolePermissions(session: Session, roleId:string): Promise<ApiPermissionList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listRolePermissions(
+    session: Session,
+    roleId: string
+  ): Promise<ApiPermissionList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listRolePermissions(session.token, roleId).then((response: ApiPermissionList) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .listRolePermissions(session.token, roleId)
+      .then((response: ApiPermissionList) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** List user roles */
-  async listRoleUsers(session: Session, roleId:string, limit?:number, cursor?:string): Promise<ApiRoleUserList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listRoleUsers(
+    session: Session,
+    roleId: string,
+    limit?: number,
+    cursor?: string
+  ): Promise<ApiRoleUserList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listRoleUsers(session.token, roleId, limit, cursor).then((response: ApiRoleUserList) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .listRoleUsers(session.token, roleId, limit, cursor)
+      .then((response: ApiRoleUserList) => {
+        return Promise.resolve(response);
+      });
   }
 
-  async registFCMDeviceToken(session: Session, tokenId:string, deviceId:string, platform:string): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async registFCMDeviceToken(
+    session: Session,
+    tokenId: string,
+    deviceId: string,
+    platform: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.registFCMDeviceToken(session.token, tokenId, deviceId, platform).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .registFCMDeviceToken(session.token, tokenId, deviceId, platform)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Get a clan desc profile */
-  async getClanDescProfile(session: Session, clanId:string): Promise<ApiClanDescProfile> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async getClanDescProfile(
+    session: Session,
+    clanId: string
+  ): Promise<ApiClanDescProfile> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.getClanDescProfile(session.token, clanId).then((response: ApiClanDescProfile) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .getClanDescProfile(session.token, clanId)
+      .then((response: ApiClanDescProfile) => {
+        return Promise.resolve(response);
+      });
   }
 
-  async getUserProfileOnClan(session: Session, clanId:string): Promise<ApiClanProfile> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async getUserProfileOnClan(
+    session: Session,
+    clanId: string
+  ): Promise<ApiClanProfile> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.getUserProfileOnClan(session.token, clanId).then((response: ApiClanProfile) => {
-      return Promise.resolve(response);
-    });
+    return this.apiClient
+      .getUserProfileOnClan(session.token, clanId)
+      .then((response: ApiClanProfile) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** Add an Apple ID to the social profiles on the current user's account. */
-  async linkApple(session: Session, request: ApiAccountApple): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkApple(
+    session: Session,
+    request: ApiAccountApple
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkApple(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkApple(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   //
-  async closeDirectMess(session: Session, request: ApiDeleteChannelDescRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async closeDirectMess(
+    session: Session,
+    request: ApiDeleteChannelDescRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.closeDirectMess(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .closeDirectMess(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
   //
-  async openDirectMess(session: Session, request: ApiDeleteChannelDescRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async openDirectMess(
+    session: Session,
+    request: ApiDeleteChannelDescRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.openDirectMess(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .openDirectMess(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add a custom ID to the social profiles on the current user's account. */
-  async linkCustom(session: Session, request: ApiAccountCustom): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkCustom(
+    session: Session,
+    request: ApiAccountCustom
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkCustom(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkCustom(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add a device ID to the social profiles on the current user's account. */
-  async linkDevice(session: Session, request: ApiAccountDevice): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkDevice(
+    session: Session,
+    request: ApiAccountDevice
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkDevice(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkDevice(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add an email+password to the social profiles on the current user's account. */
-  async linkEmail(session: Session, request: ApiAccountEmail): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkEmail(
+    session: Session,
+    request: ApiAccountEmail
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkEmail(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkEmail(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add Facebook to the social profiles on the current user's account. */
-  async linkFacebook(session: Session, request: ApiAccountFacebook): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkFacebook(
+    session: Session,
+    request: ApiAccountFacebook
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkFacebook(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkFacebook(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add Facebook Instant to the social profiles on the current user's account. */
-  async linkFacebookInstantGame(session: Session, request: ApiAccountFacebookInstantGame): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkFacebookInstantGame(
+    session: Session,
+    request: ApiAccountFacebookInstantGame
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkFacebookInstantGame(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkFacebookInstantGame(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add Google to the social profiles on the current user's account. */
-  async linkGoogle(session: Session, request: ApiAccountGoogle): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkGoogle(
+    session: Session,
+    request: ApiAccountGoogle
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkGoogle(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkGoogle(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add GameCenter to the social profiles on the current user's account. */
-  async linkGameCenter(session: Session, request: ApiAccountGameCenter): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkGameCenter(
+    session: Session,
+    request: ApiAccountGameCenter
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkGameCenter(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkGameCenter(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Add Steam to the social profiles on the current user's account. */
-  async linkSteam(session: Session, request: ApiLinkSteamRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async linkSteam(
+    session: Session,
+    request: ApiLinkSteamRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.linkSteam(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .linkSteam(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** List all friends for the current user. */
-  async listFriends(session: Session, state?: number, limit?: number, cursor?: string): Promise<Friends> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listFriends(
+    session: Session,
+    state?: number,
+    limit?: number,
+    cursor?: string
+  ): Promise<Friends> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listFriends(session.token, limit, state, cursor).then((response: ApiFriendList) => {
+    return this.apiClient
+      .listFriends(session.token, limit, state, cursor)
+      .then((response: ApiFriendList) => {
+        var result: Friends = {
+          friends: [],
+          cursor: response.cursor,
+        };
 
-      var result: Friends = {
-        friends: [],
-        cursor: response.cursor
-      };
+        if (response.friends == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.friends == null) {
+        response.friends!.forEach((f) => {
+          result.friends!.push({
+            user: {
+              avatar_url: f.user!.avatar_url,
+              create_time: f.user!.create_time,
+              display_name: f.user!.display_name,
+              edge_count: f.user!.edge_count ? Number(f.user!.edge_count) : 0,
+              facebook_id: f.user!.facebook_id,
+              gamecenter_id: f.user!.gamecenter_id,
+              google_id: f.user!.google_id,
+              id: f.user!.id,
+              lang_tag: f.user!.lang_tag,
+              location: f.user!.location,
+              online: f.user!.online,
+              steam_id: f.user!.steam_id,
+              timezone: f.user!.timezone,
+              update_time: f.user!.update_time,
+              username: f.user!.username,
+              metadata: f.user!.metadata
+                ? JSON.parse(f.user!.metadata!)
+                : undefined,
+            },
+            state: f.state,
+          });
+        });
         return Promise.resolve(result);
-      }
-
-      response.friends!.forEach(f => {
-        result.friends!.push({
-          user: {
-            avatar_url: f.user!.avatar_url,
-            create_time: f.user!.create_time,
-            display_name: f.user!.display_name,
-            edge_count: f.user!.edge_count ? Number(f.user!.edge_count) : 0,
-            facebook_id: f.user!.facebook_id,
-            gamecenter_id: f.user!.gamecenter_id,
-            google_id: f.user!.google_id,
-            id: f.user!.id,
-            lang_tag: f.user!.lang_tag,
-            location: f.user!.location,
-            online: f.user!.online,
-            steam_id: f.user!.steam_id,
-            timezone: f.user!.timezone,
-            update_time: f.user!.update_time,
-            username: f.user!.username,
-            metadata: f.user!.metadata ? JSON.parse(f.user!.metadata!) : undefined,
-          },
-          state: f.state
-        })
-      });
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** Fetch list of notifications. */
-  async listNotifications(session: Session, clanId: string, limit?: number, cacheableCursor?: string): Promise<NotificationList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async listNotifications(
+    session: Session,
+    clanId: string,
+    limit?: number,
+    cacheableCursor?: string
+  ): Promise<NotificationList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.listNotifications(session.token, clanId, limit, cacheableCursor).then((response: ApiNotificationList) => {
-      var result: NotificationList = {
-        cacheable_cursor: response.cacheable_cursor,
-        notifications: [],
-      };
+    return this.apiClient
+      .listNotifications(session.token, clanId, limit, cacheableCursor)
+      .then((response: ApiNotificationList) => {
+        var result: NotificationList = {
+          cacheable_cursor: response.cacheable_cursor,
+          notifications: [],
+        };
+
+        if (response.notifications == null) {
+          return Promise.resolve(result);
+        }
 
-      if (response.notifications == null) {
+        response.notifications!.forEach((n) => {
+          result.notifications!.push({
+            code: n.code ? Number(n.code) : 0,
+            create_time: n.create_time,
+            id: n.id,
+            persistent: n.persistent,
+            sender_id: n.sender_id,
+            subject: n.subject,
+            content: n.content ? JSON.parse(n.content) : undefined,
+          });
+        });
         return Promise.resolve(result);
-      }
-
-      response.notifications!.forEach(n => {
-        result.notifications!.push({
-          code: n.code ? Number(n.code) : 0,
-          create_time: n.create_time,
-          id: n.id,
-          persistent: n.persistent,
-          sender_id: n.sender_id,
-          subject: n.subject,
-          content: n.content ? JSON.parse(n.content) : undefined
-        })
-      });
-      return Promise.resolve(result);
-    });
+      });
   }
 
   /** Execute an RPC function on the server. */
-  async rpc(session: Session, basicAuthUsername: string,
-		basicAuthPassword: string, id: string, input: object): Promise<RpcResponse> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async rpc(
+    session: Session,
+    basicAuthUsername: string,
+    basicAuthPassword: string,
+    id: string,
+    input: object
+  ): Promise<RpcResponse> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.rpcFunc(session.token, basicAuthUsername, basicAuthPassword, id, JSON.stringify(input)).then((response: ApiRpc) => {
-      return Promise.resolve({
-        id: response.id,
-        payload: (!response.payload) ? undefined : JSON.parse(response.payload)
+    return this.apiClient
+      .rpcFunc(
+        session.token,
+        basicAuthUsername,
+        basicAuthPassword,
+        id,
+        JSON.stringify(input)
+      )
+      .then((response: ApiRpc) => {
+        return Promise.resolve({
+          id: response.id,
+          payload: !response.payload ? undefined : JSON.parse(response.payload),
+        });
       });
-    });
   }
 
   /** Execute an RPC function on the server. */
-  async rpcHttpKey(httpKey: string, id: string, input?: object): Promise<RpcResponse> {
-    return this.apiClient.rpcFunc2("", id, input && JSON.stringify(input) || "", httpKey)
+  async rpcHttpKey(
+    httpKey: string,
+    id: string,
+    input?: object
+  ): Promise<RpcResponse> {
+    return this.apiClient
+      .rpcFunc2("", id, (input && JSON.stringify(input)) || "", httpKey)
       .then((response: ApiRpc) => {
         return Promise.resolve({
           id: response.id,
-          payload: (!response.payload) ? undefined : JSON.parse(response.payload)
+          payload: !response.payload ? undefined : JSON.parse(response.payload),
         });
-      }).catch((err: any) => {
+      })
+      .catch((err: any) => {
         throw err;
       });
   }
 
   /** Log out a session, invalidate a refresh token, or log out all sessions/refresh tokens for a user. */
-  async sessionLogout(session: Session, token: string, refreshToken: string, ) : Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async sessionLogout(
+    session: Session,
+    token: string,
+    refreshToken: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.sessionLogout(session.token, {refresh_token: refreshToken, token: token}).then((response: any) => {
+    return this.apiClient
+      .sessionLogout(session.token, {
+        refresh_token: refreshToken,
+        token: token,
+      })
+      .then((response: any) => {
         return response !== undefined;
-    });
+      });
   }
 
   /** Refresh a user's session using a refresh token retrieved from a previous authentication request. */
-  async sessionRefresh(session: Session, vars: Record<string, string> = {}) : Promise<Session> {
-
+  async sessionRefresh(
+    session: Session,
+    vars: Record<string, string> = {}
+  ): Promise<Session> {
     if (!session) {
-        console.error("Cannot refresh a null session.");
-        return session;
+      console.error("Cannot refresh a null session.");
+      return session;
     }
 
     if (session.created && session.expires_at! - session.created_at < 70) {
-        console.warn("Session lifetime too short, please set '--session.token_expiry_sec' option. See the documentation for more info: https://mezon.vn/docs/mezon/getting-started/configuration/#session");
+      console.warn(
+        "Session lifetime too short, please set '--session.token_expiry_sec' option. See the documentation for more info: https://mezon.vn/docs/mezon/getting-started/configuration/#session"
+      );
     }
 
-    if (session.created && session.refresh_expires_at! - session.created_at < 3700) {
-        console.warn("Session refresh lifetime too short, please set '--session.refresh_token_expiry_sec' option. See the documentation for more info: https://mezon.vn/docs/mezon/getting-started/configuration/#session");
+    if (
+      session.created &&
+      session.refresh_expires_at! - session.created_at < 3700
+    ) {
+      console.warn(
+        "Session refresh lifetime too short, please set '--session.refresh_token_expiry_sec' option. See the documentation for more info: https://mezon.vn/docs/mezon/getting-started/configuration/#session"
+      );
     }
 
-    const apiSession = await this.apiClient.sessionRefresh(this.serverkey, "", {token: session.refresh_token, vars: vars});
+    const apiSession = await this.apiClient.sessionRefresh(this.serverkey, "", {
+      token: session.refresh_token,
+      vars: vars,
+    });
     session.update(apiSession.token!, apiSession.refresh_token!);
     return session;
   }
 
   /** Remove the Apple ID from the social profiles on the current user's account. */
-  async unlinkApple(session: Session, request: ApiAccountApple): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkApple(
+    session: Session,
+    request: ApiAccountApple
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkApple(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkApple(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-
   /** Remove custom ID from the social profiles on the current user's account. */
-  async unlinkCustom(session: Session, request: ApiAccountCustom): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkCustom(
+    session: Session,
+    request: ApiAccountCustom
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkCustom(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkCustom(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Remove a device ID from the social profiles on the current user's account. */
-  async unlinkDevice(session: Session, request: ApiAccountDevice): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkDevice(
+    session: Session,
+    request: ApiAccountDevice
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkDevice(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkDevice(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Remove an email+password from the social profiles on the current user's account. */
-  async unlinkEmail(session: Session, request: ApiAccountEmail): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkEmail(
+    session: Session,
+    request: ApiAccountEmail
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkEmail(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkEmail(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Remove Facebook from the social profiles on the current user's account. */
-  async unlinkFacebook(session: Session, request: ApiAccountFacebook): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkFacebook(
+    session: Session,
+    request: ApiAccountFacebook
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkFacebook(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkFacebook(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Remove Facebook Instant social profiles from the current user's account. */
-  async unlinkFacebookInstantGame(session: Session, request: ApiAccountFacebookInstantGame): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkFacebookInstantGame(
+    session: Session,
+    request: ApiAccountFacebookInstantGame
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkFacebookInstantGame(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkFacebookInstantGame(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Remove Google from the social profiles on the current user's account. */
-  async unlinkGoogle(session: Session, request: ApiAccountGoogle): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkGoogle(
+    session: Session,
+    request: ApiAccountGoogle
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkGoogle(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkGoogle(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Remove GameCenter from the social profiles on the current user's account. */
-  async unlinkGameCenter(session: Session, request: ApiAccountGameCenter): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkGameCenter(
+    session: Session,
+    request: ApiAccountGameCenter
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.unlinkGameCenter(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkGameCenter(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Remove Steam from the social profiles on the current user's account. */
-  async unlinkSteam(session: Session, request: ApiAccountSteam): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async unlinkSteam(
+    session: Session,
+    request: ApiAccountSteam
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
-    return this.apiClient.unlinkSteam(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .unlinkSteam(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in the current user's account. */
-  async updateAccount(session: Session, request: ApiUpdateAccountRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateAccount(
+    session: Session,
+    request: ApiUpdateAccountRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateAccount(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateAccount(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given channel */
-  async updateChannelDesc(session: Session, channelId: string, request: ApiUpdateChannelDescRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateChannelDesc(
+    session: Session,
+    channelId: string,
+    request: ApiUpdateChannelDescRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateChannelDesc(session.token, channelId, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateChannelDesc(session.token, channelId, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given clan. */
-  async updateClanDesc(session: Session, clanId: string, request: ApiUpdateClanDescRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateClanDesc(
+    session: Session,
+    clanId: string,
+    request: ApiUpdateClanDescRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateClanDesc(session.token, clanId, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateClanDesc(session.token, clanId, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given category. */
-  async updateCategory(session: Session, request: ApiUpdateCategoryDescRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateCategory(
+    session: Session,
+    request: ApiUpdateCategoryDescRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateCategory(session.token, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateCategory(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given clan profile. */
-  async updateClanDescProfile(session: Session, clanId: string, request: ApiUpdateClanDescProfileRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateClanDescProfile(
+    session: Session,
+    clanId: string,
+    request: ApiUpdateClanDescProfileRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateClanDescProfile(session.token, clanId, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateClanDescProfile(session.token, clanId, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  async updateUserProfileByClan(session: Session, clanId: string, request: ApiUpdateClanProfileRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateUserProfileByClan(
+    session: Session,
+    clanId: string,
+    request: ApiUpdateClanProfileRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateUserProfileByClan(session.token, clanId, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateUserProfileByClan(session.token, clanId, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given role. */
-  async updateRole(session: Session, roleId: string, request: ApiUpdateRoleRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateRole(
+    session: Session,
+    roleId: string,
+    request: ApiUpdateRoleRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateRole(session.token, roleId, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateRole(session.token, roleId, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given event. */
-  async updateEvent(session: Session, roleId: string, request: ApiUpdateEventRequest): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateEvent(
+    session: Session,
+    roleId: string,
+    request: ApiUpdateEventRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateEvent(session.token, roleId, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateEvent(session.token, roleId, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given event. */
-  async updateApp(session: Session, roleId: string, request: MezonUpdateAppBody): Promise<boolean> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async updateApp(
+    session: Session,
+    roleId: string,
+    request: MezonUpdateAppBody
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.updateApp(session.token, roleId, request).then((response: any) => {
-      return response !== undefined;
-    });
+    return this.apiClient
+      .updateApp(session.token, roleId, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
   /** Update fields in a given clan profile. */
-  async createLinkInviteUser(session: Session, request: ApiLinkInviteUserRequest): Promise<ApiLinkInviteUser> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async createLinkInviteUser(
+    session: Session,
+    request: ApiLinkInviteUserRequest
+  ): Promise<ApiLinkInviteUser> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
 
-    return this.apiClient.createLinkInviteUser(session.token, request).then((response: ApiLinkInviteUser) => {
-      return Promise.resolve(response);
-      
-    });
+    return this.apiClient
+      .createLinkInviteUser(session.token, request)
+      .then((response: ApiLinkInviteUser) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** Get link invite user */
-  async getLinkInvite(session: Session, inviteId:string): Promise<ApiInviteUserRes> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async getLinkInvite(
+    session: Session,
+    inviteId: string
+  ): Promise<ApiInviteUserRes> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
-    
-    return this.apiClient.getLinkInvite(session.token, inviteId).then((response: ApiInviteUserRes) => {
-      return Promise.resolve(response);
-      
-    });
+
+    return this.apiClient
+      .getLinkInvite(session.token, inviteId)
+      .then((response: ApiInviteUserRes) => {
+        return Promise.resolve(response);
+      });
   }
-  
+
   /** Get permission of user in the clan */
-  async getPermissionOfUserInTheClan(session: Session, clanId:string): Promise<ApiPermissionList> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async getPermissionOfUserInTheClan(
+    session: Session,
+    clanId: string
+  ): Promise<ApiPermissionList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
-    
-    return this.apiClient.getPermissionOfUserInTheClan(session.token, clanId).then((response: ApiPermissionList) => {
-      return Promise.resolve(response);
-      
-    });
+
+    return this.apiClient
+      .getPermissionOfUserInTheClan(session.token, clanId)
+      .then((response: ApiPermissionList) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** invite user */
-  async inviteUser(session: Session, inviteId:string): Promise<ApiInviteUserRes> {
-    if (this.autoRefreshSession && session.refresh_token &&
-        session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-        await this.sessionRefresh(session);
+  async inviteUser(
+    session: Session,
+    inviteId: string
+  ): Promise<ApiInviteUserRes> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
     }
-    
-    return this.apiClient.inviteUser(session.token, inviteId).then((response: ApiInviteUserRes) => {
-      return Promise.resolve(response);
-      
-    });
+
+    return this.apiClient
+      .inviteUser(session.token, inviteId)
+      .then((response: ApiInviteUserRes) => {
+        return Promise.resolve(response);
+      });
   }
 
   /** Set default notification clan*/
-  async setNotificationClan(session: Session, request: ApiSetDefaultNotificationRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  async setNotificationClan(
+    session: Session,
+    request: ApiSetDefaultNotificationRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.setNotificationClanSetting(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .setNotificationClanSetting(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
- /** Set notification channel*/
-async setNotificationChannel(session: Session, request: ApiSetNotificationRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  /** Set notification channel*/
+  async setNotificationChannel(
+    session: Session,
+    request: ApiSetNotificationRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.setNotificationChannelSetting(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .setNotificationChannelSetting(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
-/** Set notification category*/
-async setMuteNotificationCategory(session: Session, request: ApiSetMuteNotificationRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  /** Set notification category*/
+  async setMuteNotificationCategory(
+    session: Session,
+    request: ApiSetMuteNotificationRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.setMuteNotificationCategory(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .setMuteNotificationCategory(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
-/** Set notification channel*/
-async setMuteNotificationChannel(session: Session, request: ApiSetMuteNotificationRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  /** Set notification channel*/
+  async setMuteNotificationChannel(
+    session: Session,
+    request: ApiSetMuteNotificationRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.setMuteNotificationChannel(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .setMuteNotificationChannel(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
-/** update channel private*/
-async updateChannelPrivate(session: Session, request: ApiChangeChannelPrivateRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  /** update channel private*/
+  async updateChannelPrivate(
+    session: Session,
+    request: ApiChangeChannelPrivateRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.updateChannelPrivate(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .updateChannelPrivate(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
- /** Set default notification category*/
- async setNotificationCategory(session: Session, request: ApiSetDefaultNotificationRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  /** Set default notification category*/
+  async setNotificationCategory(
+    session: Session,
+    request: ApiSetDefaultNotificationRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.setNotificationCategorySetting(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .setNotificationCategorySetting(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
-async deleteNotificationCategory(session: Session, category_id: string): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  async deleteNotificationCategory(
+    session: Session,
+    category_id: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.deleteNotificationCategorySetting(session.token, category_id).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .deleteNotificationCategorySetting(session.token, category_id)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
-async deleteNotificationChannel(session: Session, channel_id: string): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  async deleteNotificationChannel(
+    session: Session,
+    channel_id: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
-  }
+    }
 
-  return this.apiClient.deleteNotificationChannel(session.token, channel_id).then((response: any) => {
-    return response !== undefined;
-  });
-}
+    return this.apiClient
+      .deleteNotificationChannel(session.token, channel_id)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
- /** */
- async setNotificationReactMessage(session: Session, channel_id: string): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  /** */
+  async setNotificationReactMessage(
+    session: Session,
+    channel_id: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
+    }
+
+    return this.apiClient
+      .setNotificationReactMessage(session.token, { channel_id })
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.setNotificationReactMessage(session.token, {channel_id}).then((response: any) => {
-    return response !== undefined;
-  });
-}
+  //** */
+  async deleteNotiReactMessage(
+    session: Session,
+    channel_id: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
+
+    return this.apiClient
+      .deleteNotiReactMessage(session.token, channel_id)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
-//** */
-async deleteNotiReactMessage(session: Session, channel_id: string): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+  /** query message in elasticsearch */
+  async searchMessage(
+    session: Session,
+    request: ApiSearchMessageRequest
+  ): Promise<ApiSearchMessageResponse> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
+    }
+
+    return this.apiClient
+      .searchMessage(session.token, request)
+      .then((response: ApiSearchMessageResponse) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.deleteNotiReactMessage(session.token, channel_id).then((response: any) => {
-    return response !== undefined;
-  });
-}
+  /** */
+  async createPinMessage(
+    session: Session,
+    request: ApiPinMessageRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-/** query message in elasticsearch */
-async searchMessage(session: Session, request: ApiSearchMessageRequest): Promise<ApiSearchMessageResponse> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+    return this.apiClient
+      .createPinMessage(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
+
+  async pinMessagesList(
+    session: Session,
+    channelId: string
+  ): Promise<ApiPinMessagesList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
+    }
+
+    return this.apiClient
+      .getPinMessagesList(session.token, channelId)
+      .then((response: ApiPinMessagesList) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.searchMessage(session.token, request).then((response: ApiSearchMessageResponse) => {
-    return Promise.resolve(response);
-  });
-}
+  //** */
+  async deletePinMessage(
+    session: Session,
+    message_id: string
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-/** */
-async createPinMessage(session: Session, request: ApiPinMessageRequest): Promise<boolean> {
- if (this.autoRefreshSession && session.refresh_token &&
-     session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-     await this.sessionRefresh(session);
- }
+    return this.apiClient
+      .deletePinMessage(session.token, message_id)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
 
- return this.apiClient.createPinMessage(session.token, request).then((response: any) => {
-   return response !== undefined;
- });
-}
+  /** create clan emoji */
+  async createClanEmoji(session: Session, request: ApiClanEmojiCreateRequest) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-async pinMessagesList(session: Session, channelId: string): Promise<ApiPinMessagesList> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+    return this.apiClient
+      .createClanEmoji(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
+
+  //**update clan emoji by id */
+  async updateClanEmojiById(
+    session: Session,
+    id: string,
+    request: MezonUpdateClanEmojiByIdBody
+  ) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
+    }
+
+    return this.apiClient
+      .updateClanEmojiById(session.token, id, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.getPinMessagesList(session.token, channelId).then((response: ApiPinMessagesList) => {
-    return Promise.resolve(response);
-  });
-}
+  //**delete clan emoji by id */
+  async deleteByIdClanEmoji(session: Session, id: string, clan_id: string) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//** */
-async deletePinMessage(session: Session, message_id: string): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-      session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
+    return this.apiClient
+      .deleteClanEmojiById(session.token, id, clan_id)
+      .then((response: any) => {
+        return response !== undefined;
+      });
+  }
+
+  //**create webhook for chaneel */
+  async generateWebhookLink(
+    session: Session,
+    request: ApiWebhookCreateRequest
+  ): Promise<ApiWebhookGenerateResponse> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
       await this.sessionRefresh(session);
+    }
+
+    return this.apiClient
+      .generateWebhook(session.token, request)
+      .then((response: any) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.deletePinMessage(session.token, message_id).then((response: any) => {
-    return response !== undefined;
-  });
-}
+  //**list webhook belong to the channel */
+  async listWebhookByChannelId(
+    session: Session,
+    channel_id: string,
+    clan_id: string
+  ): Promise<ApiWebhookListResponse> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-/** create clan emoji */
-async createClanEmoji(session: Session, request: ApiClanEmojiCreateRequest) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .listWebhookByChannelId(session.token, channel_id, clan_id)
+      .then((response: ApiWebhookListResponse) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.createClanEmoji(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+  //**update webhook name by id */
+  async updateWebhookById(
+    session: Session,
+    id: string,
+    request: MezonUpdateWebhookByIdBody
+  ) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**update clan emoji by id */
-async updateClanEmojiById(session: Session, id: string, request: MezonUpdateClanEmojiByIdBody) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .updateWebhookById(session.token, id, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.updateClanEmojiById(session.token, id, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+  //**disabled webhook by id */
+  async deleteWebhookById(session: Session, id: string) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**delete clan emoji by id */
-async deleteByIdClanEmoji(session: Session, id: string, clan_id: string) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .deleteWebhookById(session.token, id)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.deleteClanEmojiById(session.token, id, clan_id).then((response: any) => {
-    return response !== undefined;
-  });
-}
+  //**check duplicate clan name */
+  async checkDuplicateClanName(
+    session: Session,
+    clan_name: string
+  ): Promise<ApiCheckDuplicateClanNameResponse> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**create webhook for chaneel */
-async generateWebhookLink(session: Session, request: ApiWebhookCreateRequest): Promise<ApiWebhookGenerateResponse> {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .checkDuplicateClanName(session.token, clan_name)
+      .then((response: any) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.generateWebhook(session.token, request).then((response: any) => {
-    return Promise.resolve(response);
-  })
-}
+  //**Add a new sticker */
+  async addClanSticker(session: Session, request: ApiClanStickerAddRequest) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**list webhook belong to the channel */
-async listWebhookByChannelId(session: Session, channel_id: string, clan_id: string): Promise<ApiWebhookListResponse> {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .addClanSticker(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.listWebhookByChannelId(session.token, channel_id, clan_id).then((response: ApiWebhookListResponse) => {
-    return Promise.resolve(response);
-  })
-}
+  //**Delete a sticker by ID*/
+  async deleteClanStickerById(session: Session, id: string, clan_id: string) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**update webhook name by id */
-async updateWebhookById(session: Session, id: string, request: MezonUpdateWebhookByIdBody) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .deleteClanStickerById(session.token, id, clan_id)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.updateWebhookById(session.token, id, request).then((response: any) => {
-    return response !== undefined;
-  })
-}
+  //**Update a sticker by ID*/
+  async updateClanStickerById(
+    session: Session,
+    id: string,
+    request: MezonUpdateClanStickerByIdBody
+  ) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**disabled webhook by id */
-async deleteWebhookById(session: Session, id: string) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .updateClanStickerById(session.token, id, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.deleteWebhookById(session.token, id).then((response: any) => {
-    return response !== undefined;
-  })
-}
+  //** update the category of a channel */
+  async changeChannelCategory(
+    session: Session,
+    id: string,
+    request: MezonChangeChannelCategoryBody
+  ) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**check duplicate clan name */
-async checkDuplicateClanName(session: Session, clan_name: string): Promise<ApiCheckDuplicateClanNameResponse> {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .changeChannelCategory(session.token, id, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.checkDuplicateClanName(session.token, clan_name).then((response: any) => {
-    return Promise.resolve(response);
-  })
-}
+  /** */
+  async setRoleChannelPermission(
+    session: Session,
+    request: ApiUpdateRoleChannelRequest
+  ): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**Add a new sticker */
-async addClanSticker(session: Session, request: ApiClanStickerAddRequest) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .setRoleChannelPermission(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.addClanSticker(session.token, request).then((response: any) => {
-    return response !== undefined;
-  })
-}
+  async addApp(session: Session, request: ApiAddAppRequest): Promise<boolean> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**Delete a sticker by ID*/
-async deleteClanStickerById(session: Session, id: string, clan_id: string) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .addApp(session.token, request)
+      .then((response: any) => {
+        return response !== undefined;
+      });
   }
 
-  return this.apiClient.deleteClanStickerById(session.token, id, clan_id).then((response: any) => {
-    return response !== undefined;
-  })
-}
+  async getApp(session: Session, id: string): Promise<ApiApp> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//**Update a sticker by ID*/
-async updateClanStickerById(session: Session, id: string, request: MezonUpdateClanStickerByIdBody){
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient.getApp(session.token, id).then((response: ApiApp) => {
+      return Promise.resolve(response);
+    });
   }
 
-  return this.apiClient.updateClanStickerById(session.token, id, request).then((response: any) => {
-    return response !== undefined;
-  })
-}
+  async listApps(session: Session): Promise<ApiAppList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-//** update the category of a channel */
-async changeChannelCategory(session: Session, id: string, request: MezonChangeChannelCategoryBody) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .listApps(session.token)
+      .then((response: ApiAppList) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.changeChannelCategory(session.token, id, request).then((response: any) => {
-    return response !== undefined;
-  })
-}
+  async addAppToClan(session: Session, appId: string, clanId: string) {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-/** */
-async setRoleChannelPermission(session: Session, request: ApiUpdateRoleChannelRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .addAppToClan(session.token, appId, clanId)
+      .then((response: ApiAppList) => {
+        return response !== undefined;
+      });
   }
- 
-  return this.apiClient.setRoleChannelPermission(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
- }
 
-async addApp(session: Session, request: ApiAddAppRequest): Promise<boolean> {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+  async getSystemMessagesList(
+    session: Session
+  ): Promise<ApiSystemMessagesList> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
+
+    return this.apiClient
+      .getSystemMessagesList(session.token)
+      .then((response: ApiSystemMessagesList) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.addApp(session.token, request).then((response: any) => {
-    return response !== undefined;
-  });
-}
+  async getSystemMessageByClanId(
+    session: Session,
+    clanId: string
+  ): Promise<ApiSystemMessage> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-async getApp(session: Session, id: string): Promise<ApiApp> {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .getSystemMessageByClanId(session.token, clanId)
+      .then((response: ApiSystemMessage) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.getApp(session.token, id).then((response: ApiApp) => {
-    return Promise.resolve(response);
-  });
-}
+  async createSystemMessage(
+    session: Session,
+    request: ApiSystemMessageRequest
+  ): Promise<any> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-async listApps(session: Session): Promise<ApiAppList> {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .createSystemMessage(session.token, request)
+      .then((response: any) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.listApps(session.token).then((response: ApiAppList) => {
-    return Promise.resolve(response);
-  });
-}
+  async updateSystemMessage(
+    session: Session,
+    clanId: string,
+    request: MezonUpdateSystemMessageBody
+  ): Promise<any> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-async addAppToClan(session: Session, appId: string, clanId: string) {
-  if (this.autoRefreshSession && session.refresh_token &&
-    session.isexpired((Date.now() + this.expiredTimespanMs)/1000)) {
-    await this.sessionRefresh(session);
+    return this.apiClient
+      .updateSystemMessage(session.token, clanId, request)
+      .then((response: any) => {
+        return Promise.resolve(response);
+      });
   }
 
-  return this.apiClient.addAppToClan(session.token, appId, clanId).then((response: ApiAppList) => {
-    return response !== undefined;
-  });
-}
+  async deleteSystemMessage(session: Session, clanId: string): Promise<any> {
+    if (
+      this.autoRefreshSession &&
+      session.refresh_token &&
+      session.isexpired((Date.now() + this.expiredTimespanMs) / 1000)
+    ) {
+      await this.sessionRefresh(session);
+    }
 
-};
+    return this.apiClient
+      .deleteSystemMessage(session.token, clanId)
+      .then((response: any) => {
+        return Promise.resolve(response);
+      });
+  }
+}