@f3liz/rescript-misskey-api 0.6.7 → 0.6.9

package/src/generated/kokonect-link/wrapper/index.mjs

@@ -29,7 +29,6 @@ import * as Role from '../../generated/kokonect-link/Role.mjs';
 import * as Lists from '../../generated/kokonect-link/Lists.mjs';
 import * as Chat from '../../generated/kokonect-link/Chat.mjs';
 import * as Groups from '../../generated/kokonect-link/Groups.mjs';
-
 export class MisskeyClient {
   constructor(baseUrl, token) {
     this.baseUrl = baseUrl;
@@ -50,939 +49,782 @@ export class MisskeyClient {
   }
 }
 
-
 export const Admin = {
-
   async postAdminAbuseReportResolverCreate(client, request) {
     return Admin.postAdminAbuseReportResolverCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportResolverDelete(client, request) {
     return Admin.postAdminAbuseReportResolverDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportResolverList(client, request) {
     return Admin.postAdminAbuseReportResolverList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportResolverUpdate(client, request) {
     return Admin.postAdminAbuseReportResolverUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientCreate(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientDelete(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientList(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientShow(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientUpdate(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseUserReports(client, request) {
     return Admin.postAdminAbuseUserReports({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsCreate(client, request) {
     return Admin.postAdminAccountsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsDelete(client, request) {
     return Admin.postAdminAccountsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsFindByEmail(client, request) {
     return Admin.postAdminAccountsFindByEmail({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsPendingList(client, request) {
     return Admin.postAdminAccountsPendingList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsPendingRevoke(client, request) {
     return Admin.postAdminAccountsPendingRevoke({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAdCreate(client, request) {
     return Admin.postAdminAdCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAdDelete(client, request) {
     return Admin.postAdminAdDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAdList(client, request) {
     return Admin.postAdminAdList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAdUpdate(client, request) {
     return Admin.postAdminAdUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAnnouncementsCreate(client, request) {
     return Admin.postAdminAnnouncementsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAnnouncementsDelete(client, request) {
     return Admin.postAdminAnnouncementsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAnnouncementsList(client, request) {
     return Admin.postAdminAnnouncementsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAnnouncementsUpdate(client, request) {
     return Admin.postAdminAnnouncementsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAvatarDecorationsCreate(client, request) {
     return Admin.postAdminAvatarDecorationsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAvatarDecorationsDelete(client, request) {
     return Admin.postAdminAvatarDecorationsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAvatarDecorationsList(client, request) {
     return Admin.postAdminAvatarDecorationsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAvatarDecorationsUpdate(client, request) {
     return Admin.postAdminAvatarDecorationsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminCaptchaCurrent(client) {
     return Admin.postAdminCaptchaCurrent({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminCaptchaSave(client, request) {
     return Admin.postAdminCaptchaSave({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDriveCleanRemoteFiles(client) {
     return Admin.postAdminDriveCleanRemoteFiles({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDriveCleanup(client) {
     return Admin.postAdminDriveCleanup({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDriveDeleteAllFilesOfAUser(client, request) {
     return Admin.postAdminDriveDeleteAllFilesOfAUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDriveFiles(client, request) {
     return Admin.postAdminDriveFiles({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDriveShowFile(client, request) {
     return Admin.postAdminDriveShowFile({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiAdd(client, request) {
     return Admin.postAdminEmojiAdd({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiAddAliasesBulk(client, request) {
     return Admin.postAdminEmojiAddAliasesBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiCopy(client, request) {
     return Admin.postAdminEmojiCopy({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiDelete(client, request) {
     return Admin.postAdminEmojiDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiDeleteBulk(client, request) {
     return Admin.postAdminEmojiDeleteBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiList(client, request) {
     return Admin.postAdminEmojiList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiListRemote(client, request) {
     return Admin.postAdminEmojiListRemote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiRemoveAliasesBulk(client, request) {
     return Admin.postAdminEmojiRemoveAliasesBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiSetAliasesBulk(client, request) {
     return Admin.postAdminEmojiSetAliasesBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiSetCategoryBulk(client, request) {
     return Admin.postAdminEmojiSetCategoryBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiSetLicenseBulk(client, request) {
     return Admin.postAdminEmojiSetLicenseBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiUpdate(client, request) {
     return Admin.postAdminEmojiUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminFederationDeleteAllFiles(client, request) {
     return Admin.postAdminFederationDeleteAllFiles({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminFederationRefreshRemoteInstanceMetadata(client, request) {
     return Admin.postAdminFederationRefreshRemoteInstanceMetadata({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminFederationRemoveAllFollowing(client, request) {
     return Admin.postAdminFederationRemoveAllFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminFederationUpdateInstance(client, request) {
     return Admin.postAdminFederationUpdateInstance({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminForwardAbuseUserReport(client, request) {
     return Admin.postAdminForwardAbuseUserReport({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminGetIndexStats(client) {
     return Admin.postAdminGetIndexStats({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminGetTableStats(client) {
     return Admin.postAdminGetTableStats({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminGetUserIps(client, request) {
     return Admin.postAdminGetUserIps({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminIndieAuthCreate(client, request) {
     return Admin.postAdminIndieAuthCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminIndieAuthDelete(client, request) {
     return Admin.postAdminIndieAuthDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminIndieAuthList(client, request) {
     return Admin.postAdminIndieAuthList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminIndieAuthUpdate(client, request) {
     return Admin.postAdminIndieAuthUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminInviteCreate(client, request) {
     return Admin.postAdminInviteCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminInviteList(client, request) {
     return Admin.postAdminInviteList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminPromoCreate(client, request) {
     return Admin.postAdminPromoCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueClear(client, request) {
     return Admin.postAdminQueueClear({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueDeliverDelayed(client) {
     return Admin.postAdminQueueDeliverDelayed({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueInboxDelayed(client) {
     return Admin.postAdminQueueInboxDelayed({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueuePromote(client, request) {
     return Admin.postAdminQueuePromote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueStats(client) {
     return Admin.postAdminQueueStats({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRegenerateUserToken(client, request) {
     return Admin.postAdminRegenerateUserToken({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRelaysAdd(client, request) {
     return Admin.postAdminRelaysAdd({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRelaysList(client) {
     return Admin.postAdminRelaysList({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRelaysRemove(client, request) {
     return Admin.postAdminRelaysRemove({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminResetPassword(client, request) {
     return Admin.postAdminResetPassword({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminResolveAbuseUserReport(client, request) {
     return Admin.postAdminResolveAbuseUserReport({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesAssign(client, request) {
     return Admin.postAdminRolesAssign({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesCreate(client, request) {
     return Admin.postAdminRolesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesDelete(client, request) {
     return Admin.postAdminRolesDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesList(client) {
     return Admin.postAdminRolesList({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesShow(client, request) {
     return Admin.postAdminRolesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesUnassign(client, request) {
     return Admin.postAdminRolesUnassign({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesUpdate(client, request) {
     return Admin.postAdminRolesUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesUpdateDefaultPolicies(client, request) {
     return Admin.postAdminRolesUpdateDefaultPolicies({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesUpdateInlinePolicies(client, request) {
     return Admin.postAdminRolesUpdateInlinePolicies({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesUsers(client, request) {
     return Admin.postAdminRolesUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSendEmail(client, request) {
     return Admin.postAdminSendEmail({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminShowModerationLogs(client, request) {
     return Admin.postAdminShowModerationLogs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminShowUser(client, request) {
     return Admin.postAdminShowUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminShowUserAccountMoveLogs(client, request) {
     return Admin.postAdminShowUserAccountMoveLogs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminShowUsers(client, request) {
     return Admin.postAdminShowUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSsoCreate(client, request) {
     return Admin.postAdminSsoCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSsoDelete(client, request) {
     return Admin.postAdminSsoDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSsoList(client, request) {
     return Admin.postAdminSsoList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSsoUpdate(client, request) {
     return Admin.postAdminSsoUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSuspendUser(client, request) {
     return Admin.postAdminSuspendUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookCreate(client, request) {
     return Admin.postAdminSystemWebhookCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookDelete(client, request) {
     return Admin.postAdminSystemWebhookDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookList(client, request) {
     return Admin.postAdminSystemWebhookList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookShow(client, request) {
     return Admin.postAdminSystemWebhookShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookUpdate(client, request) {
     return Admin.postAdminSystemWebhookUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUnsetUserAvatar(client, request) {
     return Admin.postAdminUnsetUserAvatar({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUnsetUserBanner(client, request) {
     return Admin.postAdminUnsetUserBanner({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUnsetUserMutualLink(client, request) {
     return Admin.postAdminUnsetUserMutualLink({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUnsuspendUser(client, request) {
     return Admin.postAdminUnsuspendUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUpdateAbuseUserReport(client, request) {
     return Admin.postAdminUpdateAbuseUserReport({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUpdateMeta(client, request) {
     return Admin.postAdminUpdateMeta({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUpdateProxyAccount(client, request) {
     return Admin.postAdminUpdateProxyAccount({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUpdateUserName(client, request) {
     return Admin.postAdminUpdateUserName({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUpdateUserNote(client, request) {
     return Admin.postAdminUpdateUserNote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postV2AdminEmojiList(client, request) {
     return Admin.postV2AdminEmojiList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientCreate(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientShow(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseReportNotificationRecipientUpdate(client, request) {
     return Admin.postAdminAbuseReportNotificationRecipientUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAbuseUserReports(client, request) {
     return Admin.postAdminAbuseUserReports({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsCreate(client, request) {
     return Admin.postAdminAccountsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsDelete(client, request) {
     return Admin.postAdminAccountsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAccountsFindByEmail(client, request) {
     return Admin.postAdminAccountsFindByEmail({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAdCreate(client, request) {
     return Admin.postAdminAdCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAdList(client, request) {
     return Admin.postAdminAdList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAnnouncementsCreate(client, request) {
     return Admin.postAdminAnnouncementsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAnnouncementsList(client, request) {
     return Admin.postAdminAnnouncementsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAnnouncementsUpdate(client, request) {
     return Admin.postAdminAnnouncementsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAvatarDecorationsCopy(client, request) {
     return Admin.postAdminAvatarDecorationsCopy({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAvatarDecorationsList(client, request) {
     return Admin.postAdminAvatarDecorationsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminAvatarDecorationsListRemote(client, request) {
     return Admin.postAdminAvatarDecorationsListRemote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDeleteAccount(client, request) {
     return Admin.postAdminDeleteAccount({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDeleteAllFilesOfAUser(client, request) {
     return Admin.postAdminDeleteAllFilesOfAUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDriveFiles(client, request) {
     return Admin.postAdminDriveFiles({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminDriveShowFile(client, request) {
     return Admin.postAdminDriveShowFile({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiAdd(client, request) {
     return Admin.postAdminEmojiAdd({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiList(client, request) {
     return Admin.postAdminEmojiList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiListRemote(client, request) {
     return Admin.postAdminEmojiListRemote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiSteal(client, request) {
     return Admin.postAdminEmojiSteal({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminEmojiUpdate(client, request) {
     return Admin.postAdminEmojiUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminInviteRevoke(client) {
     return Admin.postAdminInviteRevoke({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueClear(client, request) {
     return Admin.postAdminQueueClear({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueJobs(client, request) {
     return Admin.postAdminQueueJobs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueuePromoteJobs(client, request) {
     return Admin.postAdminQueuePromoteJobs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueQueueStats(client, request) {
     return Admin.postAdminQueueQueueStats({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueQueues(client) {
     return Admin.postAdminQueueQueues({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueRemoveJob(client, request) {
     return Admin.postAdminQueueRemoveJob({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueRetryJob(client, request) {
     return Admin.postAdminQueueRetryJob({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueShowJob(client, request) {
     return Admin.postAdminQueueShowJob({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminQueueShowJobLogs(client, request) {
     return Admin.postAdminQueueShowJobLogs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminResolveAbuseUserReport(client, request) {
     return Admin.postAdminResolveAbuseUserReport({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesAssign(client, request) {
     return Admin.postAdminRolesAssign({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesCreate(client, request) {
     return Admin.postAdminRolesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesShow(client, request) {
     return Admin.postAdminRolesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesUpdate(client, request) {
     return Admin.postAdminRolesUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminRolesUsers(client, request) {
     return Admin.postAdminRolesUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminServerInfo(client) {
     return Admin.postAdminServerInfo({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminShowModerationLogs(client, request) {
     return Admin.postAdminShowModerationLogs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminShowUser(client, request) {
     return Admin.postAdminShowUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookCreate(client, request) {
     return Admin.postAdminSystemWebhookCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookShow(client, request) {
     return Admin.postAdminSystemWebhookShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookUpdate(client, request) {
     return Admin.postAdminSystemWebhookUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUpdateMeta(client, request) {
     return Admin.postAdminUpdateMeta({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminUpdateProxyAccount(client, request) {
     return Admin.postAdminUpdateProxyAccount({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postV2AdminEmojiList(client, request) {
     return Admin.postV2AdminEmojiList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -990,393 +832,327 @@ export const Admin = {
   },
 };
 
-
 export const Default = {
-
   async postAdminEmojiImportZip(client, request) {
     return Default.postAdminEmojiImportZip({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getBubbleGameRanking(client, request) {
     return Default.getBubbleGameRanking({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postBubbleGameRanking(client, request) {
     return Default.postBubbleGameRanking({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postBubbleGameRegister(client, request) {
     return Default.postBubbleGameRegister({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postExportCustomEmojis(client) {
     return Default.postExportCustomEmojis({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faDone(client, request) {
     return Default.postI2faDone({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faKeyDone(client, request) {
     return Default.postI2faKeyDone({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faPasswordLess(client, request) {
     return Default.postI2faPasswordLess({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faRegister(client, request) {
     return Default.postI2faRegister({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faRegisterKey(client, request) {
     return Default.postI2faRegisterKey({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faRemoveKey(client, request) {
     return Default.postI2faRemoveKey({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faUnregister(client, request) {
     return Default.postI2faUnregister({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI2faUpdateKey(client, request) {
     return Default.postI2faUpdateKey({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIApps(client, request) {
     return Default.postIApps({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIAuthorizedApps(client, request) {
     return Default.postIAuthorizedApps({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIChangePassword(client, request) {
     return Default.postIChangePassword({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIClaimAchievement(client, request) {
     return Default.postIClaimAchievement({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIDeleteAccount(client, request) {
     return Default.postIDeleteAccount({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportAntennas(client) {
     return Default.postIExportAntennas({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportBlocking(client) {
     return Default.postIExportBlocking({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportClips(client) {
     return Default.postIExportClips({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportFavorites(client) {
     return Default.postIExportFavorites({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportFollowing(client, request) {
     return Default.postIExportFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportMute(client) {
     return Default.postIExportMute({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportNotes(client) {
     return Default.postIExportNotes({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIExportUserLists(client) {
     return Default.postIExportUserLists({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIImportAntennas(client, request) {
     return Default.postIImportAntennas({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIImportBlocking(client, request) {
     return Default.postIImportBlocking({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIImportFollowing(client, request) {
     return Default.postIImportFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIImportMuting(client, request) {
     return Default.postIImportMuting({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIImportUserLists(client, request) {
     return Default.postIImportUserLists({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegenerateToken(client, request) {
     return Default.postIRegenerateToken({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistryGet(client, request) {
     return Default.postIRegistryGet({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistryGetAll(client, request) {
     return Default.postIRegistryGetAll({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistryGetDetail(client, request) {
     return Default.postIRegistryGetDetail({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistryKeys(client, request) {
     return Default.postIRegistryKeys({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistryKeysWithType(client, request) {
     return Default.postIRegistryKeysWithType({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistryRemove(client, request) {
     return Default.postIRegistryRemove({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistryScopesWithDomain(client) {
     return Default.postIRegistryScopesWithDomain({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRegistrySet(client, request) {
     return Default.postIRegistrySet({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRevokeToken(client, request) {
     return Default.postIRevokeToken({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postISigninHistory(client, request) {
     return Default.postISigninHistory({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUpdateEmail(client, request) {
     return Default.postIUpdateEmail({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagePush(client, request) {
     return Default.postPagePush({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiCancelMatch(client, request) {
     return Default.postReversiCancelMatch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiGames(client, request) {
     return Default.postReversiGames({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiInvitations(client) {
     return Default.postReversiInvitations({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiMatch(client, request) {
     return Default.postReversiMatch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiShowGame(client, request) {
     return Default.postReversiShowGame({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiSurrender(client, request) {
     return Default.postReversiSurrender({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiVerify(client, request) {
     return Default.postReversiVerify({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersAchievements(client, request) {
     return Default.postUsersAchievements({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsCreateFromPublic(client, request) {
     return Default.postUsersListsCreateFromPublic({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsFavorite(client, request) {
     return Default.postUsersListsFavorite({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsUnfavorite(client, request) {
     return Default.postUsersListsUnfavorite({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIClaimAchievement(client, request) {
     return Default.postIClaimAchievement({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIRevokeToken(client, request) {
     return Default.postIRevokeToken({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postISigninHistory(client, request) {
     return Default.postISigninHistory({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postITruncateAccount(client, request) {
     return Default.postITruncateAccount({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUpdateEmail(client, request) {
     return Default.postIUpdateEmail({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiGames(client, request) {
     return Default.postReversiGames({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiMatch(client, request) {
     return Default.postReversiMatch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiShowGame(client, request) {
     return Default.postReversiShowGame({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postReversiVerify(client, request) {
     return Default.postReversiVerify({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsCreateFromPublic(client, request) {
     return Default.postUsersListsCreateFromPublic({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -1384,201 +1160,167 @@ export const Default = {
   },
 };
 
-
 export const Meta = {
-
   async postAdminMeta(client) {
     return Meta.postAdminMeta({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAnnouncement(client, request) {
     return Meta.postAnnouncement({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAnnouncements(client, request) {
     return Meta.postAnnouncements({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAnnouncementsShow(client, request) {
     return Meta.postAnnouncementsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getEmoji(client, request) {
     return Meta.getEmoji({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postEmoji(client, request) {
     return Meta.postEmoji({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getEmojis(client) {
     return Meta.getEmojis({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postEmojis(client) {
     return Meta.postEmojis({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postEndpoint(client, request) {
     return Meta.postEndpoint({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postEndpoints(client) {
     return Meta.postEndpoints({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFetchExternalResources(client, request) {
     return Meta.postFetchExternalResources({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getFetchRss(client, request) {
     return Meta.getFetchRss({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFetchRss(client, request) {
     return Meta.postFetchRss({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getGetOnlineUsersCount(client) {
     return Meta.getGetOnlineUsersCount({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGetOnlineUsersCount(client) {
     return Meta.postGetOnlineUsersCount({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postInviteCreate(client) {
     return Meta.postInviteCreate({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postInviteDelete(client, request) {
     return Meta.postInviteDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postInviteLimit(client) {
     return Meta.postInviteLimit({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postInviteList(client, request) {
     return Meta.postInviteList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getMeta(client, request) {
     return Meta.getMeta({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postMeta(client, request) {
     return Meta.postMeta({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPing(client) {
     return Meta.postPing({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getStats(client) {
     return Meta.getStats({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postStats(client) {
     return Meta.postStats({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminMeta(client) {
     return Meta.postAdminMeta({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAnnouncements(client, request) {
     return Meta.postAnnouncements({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAnnouncementsShow(client, request) {
     return Meta.postAnnouncementsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getEmoji(client, request) {
     return Meta.getEmoji({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postEmoji(client, request) {
     return Meta.postEmoji({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postInviteCreate(client) {
     return Meta.postInviteCreate({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postInviteList(client, request) {
     return Meta.postInviteList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getServerInfo(client) {
     return Meta.getServerInfo({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postServerInfo(client) {
     return Meta.postServerInfo({
       fetch: (url, method, body) => client._fetch(url, method, body)
@@ -1586,63 +1328,52 @@ export const Meta = {
   },
 };
 
-
 export const Webhooks = {
-
   async postAdminSystemWebhookTest(client, request) {
     return Webhooks.postAdminSystemWebhookTest({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksCreate(client, request) {
     return Webhooks.postIWebhooksCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksDelete(client, request) {
     return Webhooks.postIWebhooksDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksList(client) {
     return Webhooks.postIWebhooksList({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksShow(client, request) {
     return Webhooks.postIWebhooksShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksTest(client, request) {
     return Webhooks.postIWebhooksTest({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksUpdate(client, request) {
     return Webhooks.postIWebhooksUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAdminSystemWebhookTest(client, request) {
     return Webhooks.postAdminSystemWebhookTest({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksShow(client, request) {
     return Webhooks.postIWebhooksShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIWebhooksTest(client, request) {
     return Webhooks.postIWebhooksTest({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -1650,57 +1381,47 @@ export const Webhooks = {
   },
 };
 
-
 export const Antennas = {
-
   async postAntennasCreate(client, request) {
     return Antennas.postAntennasCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasDelete(client, request) {
     return Antennas.postAntennasDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasList(client) {
     return Antennas.postAntennasList({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasNotes(client, request) {
     return Antennas.postAntennasNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasShow(client, request) {
     return Antennas.postAntennasShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasUpdate(client, request) {
     return Antennas.postAntennasUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasCreate(client, request) {
     return Antennas.postAntennasCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasShow(client, request) {
     return Antennas.postAntennasShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAntennasUpdate(client, request) {
     return Antennas.postAntennasUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -1708,105 +1429,87 @@ export const Antennas = {
   },
 };
 
-
 export const Federation = {
-
   async postApGet(client, request) {
     return Federation.postApGet({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postApShow(client, request) {
     return Federation.postApShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationFollowers(client, request) {
     return Federation.postFederationFollowers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationFollowing(client, request) {
     return Federation.postFederationFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getFederationInstances(client, request) {
     return Federation.getFederationInstances({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationInstances(client, request) {
     return Federation.postFederationInstances({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationShowInstance(client, request) {
     return Federation.postFederationShowInstance({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getFederationStats(client, request) {
     return Federation.getFederationStats({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationStats(client, request) {
     return Federation.postFederationStats({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationUpdateRemoteUser(client, request) {
     return Federation.postFederationUpdateRemoteUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationUsers(client, request) {
     return Federation.postFederationUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationFollowers(client, request) {
     return Federation.postFederationFollowers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationFollowing(client, request) {
     return Federation.postFederationFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getFederationRemoteSoftware(client, request) {
     return Federation.getFederationRemoteSoftware({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationRemoteSoftware(client, request) {
     return Federation.postFederationRemoteSoftware({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationShowInstance(client, request) {
     return Federation.postFederationShowInstance({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFederationUsers(client, request) {
     return Federation.postFederationUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -1814,27 +1517,22 @@ export const Federation = {
   },
 };
 
-
 export const App = {
-
   async postAppCreate(client, request) {
     return App.postAppCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAppShow(client, request) {
     return App.postAppShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAppCreate(client, request) {
     return App.postAppCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAppShow(client, request) {
     return App.postAppShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -1842,45 +1540,37 @@ export const App = {
   },
 };
 
-
 export const Auth = {
-
   async postAuthAccept(client, request) {
     return Auth.postAuthAccept({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAuthSessionGenerate(client, request) {
     return Auth.postAuthSessionGenerate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAuthSessionShow(client, request) {
     return Auth.postAuthSessionShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAuthSessionUserkey(client, request) {
     return Auth.postAuthSessionUserkey({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postMiauthGenToken(client, request) {
     return Auth.postMiauthGenToken({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAuthSessionShow(client, request) {
     return Auth.postAuthSessionShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postAuthSessionUserkey(client, request) {
     return Auth.postAuthSessionUserkey({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -1888,351 +1578,292 @@ export const Auth = {
   },
 };
 
-
 export const Account = {
-
   async postBlockingCreate(client, request) {
     return Account.postBlockingCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postBlockingDelete(client, request) {
     return Account.postBlockingDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postBlockingList(client, request) {
     return Account.postBlockingList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsAddNote(client, request) {
     return Account.postClipsAddNote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsMyFavorites(client) {
     return Account.postClipsMyFavorites({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsNotes(client, request) {
     return Account.postClipsNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsRemoveNote(client, request) {
     return Account.postClipsRemoveNote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashMy(client, request) {
     return Account.postFlashMy({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashMyLikes(client, request) {
     return Account.postFlashMyLikes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI(client) {
     return Account.postI({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIFavorites(client, request) {
     return Account.postIFavorites({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIGalleryLikes(client, request) {
     return Account.postIGalleryLikes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIGalleryPosts(client, request) {
     return Account.postIGalleryPosts({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postINotifications(client, request) {
     return Account.postINotifications({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postINotificationsGrouped(client, request) {
     return Account.postINotificationsGrouped({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIPageLikes(client, request) {
     return Account.postIPageLikes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIPages(client, request) {
     return Account.postIPages({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIPin(client, request) {
     return Account.postIPin({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIPurgeTimelineCache(client, request) {
     return Account.postIPurgeTimelineCache({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIReadAnnouncement(client, request) {
     return Account.postIReadAnnouncement({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUnpin(client, request) {
     return Account.postIUnpin({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUpdate(client, request) {
     return Account.postIUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postMuteCreate(client, request) {
     return Account.postMuteCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postMuteDelete(client, request) {
     return Account.postMuteDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postMuteList(client, request) {
     return Account.postMuteList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postMyApps(client, request) {
     return Account.postMyApps({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRenoteMuteCreate(client, request) {
     return Account.postRenoteMuteCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRenoteMuteDelete(client, request) {
     return Account.postRenoteMuteDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRenoteMuteList(client, request) {
     return Account.postRenoteMuteList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postSwRegister(client, request) {
     return Account.postSwRegister({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postSwShowRegistration(client, request) {
     return Account.postSwShowRegistration({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postSwUnregister(client, request) {
     return Account.postSwUnregister({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postSwUpdateRegistration(client, request) {
     return Account.postSwUpdateRegistration({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersUpdateMemo(client, request) {
     return Account.postUsersUpdateMemo({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postBlockingCreate(client, request) {
     return Account.postBlockingCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postBlockingDelete(client, request) {
     return Account.postBlockingDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postBlockingList(client, request) {
     return Account.postBlockingList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsNotes(client, request) {
     return Account.postClipsNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashMy(client, request) {
     return Account.postFlashMy({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashMyLikes(client, request) {
     return Account.postFlashMyLikes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postI(client) {
     return Account.postI({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIAutoDeleteSettings(client) {
     return Account.postIAutoDeleteSettings({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIFavorites(client, request) {
     return Account.postIFavorites({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIFollowersServers(client) {
     return Account.postIFollowersServers({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIGalleryLikes(client, request) {
     return Account.postIGalleryLikes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIGalleryPosts(client, request) {
     return Account.postIGalleryPosts({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postINotifications(client, request) {
     return Account.postINotifications({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postINotificationsGrouped(client, request) {
     return Account.postINotificationsGrouped({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIPageLikes(client, request) {
     return Account.postIPageLikes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIPages(client, request) {
     return Account.postIPages({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIPin(client, request) {
     return Account.postIPin({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUnpin(client, request) {
     return Account.postIUnpin({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUpdate(client, request) {
     return Account.postIUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUpdateAutoDeleteSettings(client, request) {
     return Account.postIUpdateAutoDeleteSettings({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIUserGroupInvites(client, request) {
     return Account.postIUserGroupInvites({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postMuteList(client, request) {
     return Account.postMuteList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRenoteMuteList(client, request) {
     return Account.postRenoteMuteList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postVerifyEmail(client, request) {
     return Account.postVerifyEmail({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -2240,117 +1871,97 @@ export const Account = {
   },
 };
 
-
 export const Channels = {
-
   async postChannelsCreate(client, request) {
     return Channels.postChannelsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsFavorite(client, request) {
     return Channels.postChannelsFavorite({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsFeatured(client) {
     return Channels.postChannelsFeatured({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsFeaturedGames(client) {
     return Channels.postChannelsFeaturedGames({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsFollow(client, request) {
     return Channels.postChannelsFollow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsFollowed(client, request) {
     return Channels.postChannelsFollowed({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsMyFavorites(client) {
     return Channels.postChannelsMyFavorites({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsOwned(client, request) {
     return Channels.postChannelsOwned({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsSearch(client, request) {
     return Channels.postChannelsSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsShow(client, request) {
     return Channels.postChannelsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsUnfavorite(client, request) {
     return Channels.postChannelsUnfavorite({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsUnfollow(client, request) {
     return Channels.postChannelsUnfollow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsUpdate(client, request) {
     return Channels.postChannelsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsCreate(client, request) {
     return Channels.postChannelsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsFollowed(client, request) {
     return Channels.postChannelsFollowed({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsOwned(client, request) {
     return Channels.postChannelsOwned({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsSearch(client, request) {
     return Channels.postChannelsSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsShow(client, request) {
     return Channels.postChannelsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsUpdate(client, request) {
     return Channels.postChannelsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -2358,387 +1969,322 @@ export const Channels = {
   },
 };
 
-
 export const Notes = {
-
   async postChannelsTimeline(client, request) {
     return Notes.postChannelsTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotes(client, request) {
     return Notes.postNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesChildren(client, request) {
     return Notes.postNotesChildren({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesConversation(client, request) {
     return Notes.postNotesConversation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesCreate(client, request) {
     return Notes.postNotesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesDelete(client, request) {
     return Notes.postNotesDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesFavoritesCreate(client, request) {
     return Notes.postNotesFavoritesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesFavoritesDelete(client, request) {
     return Notes.postNotesFavoritesDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getNotesFeatured(client, request) {
     return Notes.getNotesFeatured({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesFeatured(client, request) {
     return Notes.postNotesFeatured({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesGlobalTimeline(client, request) {
     return Notes.postNotesGlobalTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesHybridTimeline(client, request) {
     return Notes.postNotesHybridTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesLocalTimeline(client, request) {
     return Notes.postNotesLocalTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesMentions(client, request) {
     return Notes.postNotesMentions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesPollsRecommendation(client, request) {
     return Notes.postNotesPollsRecommendation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesPollsVote(client, request) {
     return Notes.postNotesPollsVote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getNotesReactions(client, request) {
     return Notes.getNotesReactions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesReactions(client, request) {
     return Notes.postNotesReactions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesRenotes(client, request) {
     return Notes.postNotesRenotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesReplies(client, request) {
     return Notes.postNotesReplies({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesScheduledCancel(client, request) {
     return Notes.postNotesScheduledCancel({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesScheduledList(client, request) {
     return Notes.postNotesScheduledList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesSearch(client, request) {
     return Notes.postNotesSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesSearchByTag(client, request) {
     return Notes.postNotesSearchByTag({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesShow(client, request) {
     return Notes.postNotesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesState(client, request) {
     return Notes.postNotesState({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesThreadMutingCreate(client, request) {
     return Notes.postNotesThreadMutingCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesThreadMutingDelete(client, request) {
     return Notes.postNotesThreadMutingDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesTimeline(client, request) {
     return Notes.postNotesTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesTranslate(client, request) {
     return Notes.postNotesTranslate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesUnrenote(client, request) {
     return Notes.postNotesUnrenote({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesUserListTimeline(client, request) {
     return Notes.postNotesUserListTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPromoRead(client, request) {
     return Notes.postPromoRead({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getUsersFeaturedNotes(client, request) {
     return Notes.getUsersFeaturedNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersFeaturedNotes(client, request) {
     return Notes.postUsersFeaturedNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChannelsTimeline(client, request) {
     return Notes.postChannelsTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotes(client, request) {
     return Notes.postNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesBubbleTimeline(client, request) {
     return Notes.postNotesBubbleTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesChildren(client, request) {
     return Notes.postNotesChildren({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesCreate(client, request) {
     return Notes.postNotesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesDraftsCount(client) {
     return Notes.postNotesDraftsCount({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesDraftsCreate(client, request) {
     return Notes.postNotesDraftsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesDraftsDelete(client, request) {
     return Notes.postNotesDraftsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesDraftsList(client, request) {
     return Notes.postNotesDraftsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesDraftsUpdate(client, request) {
     return Notes.postNotesDraftsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesEventsSearch(client, request) {
     return Notes.postNotesEventsSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesGlobalTimeline(client, request) {
     return Notes.postNotesGlobalTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesHistory(client, request) {
     return Notes.postNotesHistory({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesHybridTimeline(client, request) {
     return Notes.postNotesHybridTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesLocalTimeline(client, request) {
     return Notes.postNotesLocalTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesMentions(client, request) {
     return Notes.postNotesMentions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesPollsTranslate(client, request) {
     return Notes.postNotesPollsTranslate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getNotesReactions(client, request) {
     return Notes.getNotesReactions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesReactions(client, request) {
     return Notes.postNotesReactions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesRenotes(client, request) {
     return Notes.postNotesRenotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesReplies(client, request) {
     return Notes.postNotesReplies({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesSearch(client, request) {
     return Notes.postNotesSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesSearchByTag(client, request) {
     return Notes.postNotesSearchByTag({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesShow(client, request) {
     return Notes.postNotesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesShowPartialBulk(client, request) {
     return Notes.postNotesShowPartialBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesState(client, request) {
     return Notes.postNotesState({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesTimeline(client, request) {
     return Notes.postNotesTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesUpdate(client, request) {
     return Notes.postNotesUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesUserListTimeline(client, request) {
     return Notes.postNotesUserListTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -2746,159 +2292,132 @@ export const Notes = {
   },
 };
 
-
 export const Charts = {
-
   async getChartsActiveUsers(client, request) {
     return Charts.getChartsActiveUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsActiveUsers(client, request) {
     return Charts.postChartsActiveUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsApRequest(client, request) {
     return Charts.getChartsApRequest({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsApRequest(client, request) {
     return Charts.postChartsApRequest({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsDrive(client, request) {
     return Charts.getChartsDrive({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsDrive(client, request) {
     return Charts.postChartsDrive({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsFederation(client, request) {
     return Charts.getChartsFederation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsFederation(client, request) {
     return Charts.postChartsFederation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsInstance(client, request) {
     return Charts.getChartsInstance({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsInstance(client, request) {
     return Charts.postChartsInstance({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsNotes(client, request) {
     return Charts.getChartsNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsNotes(client, request) {
     return Charts.postChartsNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsUserDrive(client, request) {
     return Charts.getChartsUserDrive({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsUserDrive(client, request) {
     return Charts.postChartsUserDrive({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsUserFollowing(client, request) {
     return Charts.getChartsUserFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsUserFollowing(client, request) {
     return Charts.postChartsUserFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsUserNotes(client, request) {
     return Charts.getChartsUserNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsUserNotes(client, request) {
     return Charts.postChartsUserNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsUserPv(client, request) {
     return Charts.getChartsUserPv({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsUserPv(client, request) {
     return Charts.postChartsUserPv({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsUserReactions(client, request) {
     return Charts.getChartsUserReactions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsUserReactions(client, request) {
     return Charts.postChartsUserReactions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsUsers(client, request) {
     return Charts.getChartsUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsUsers(client, request) {
     return Charts.postChartsUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getChartsFederation(client, request) {
     return Charts.getChartsFederation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChartsFederation(client, request) {
     return Charts.postChartsFederation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -2906,63 +2425,52 @@ export const Charts = {
   },
 };
 
-
 export const Clips = {
-
   async postClipsCreate(client, request) {
     return Clips.postClipsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsDelete(client, request) {
     return Clips.postClipsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsList(client) {
     return Clips.postClipsList({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsShow(client, request) {
     return Clips.postClipsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsUpdate(client, request) {
     return Clips.postClipsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesClips(client, request) {
     return Clips.postNotesClips({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsCreate(client, request) {
     return Clips.postClipsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsList(client, request) {
     return Clips.postClipsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsShow(client, request) {
     return Clips.postClipsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsUpdate(client, request) {
     return Clips.postClipsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -2970,15 +2478,12 @@ export const Clips = {
   },
 };
 
-
 export const Clip = {
-
   async postClipsFavorite(client, request) {
     return Clip.postClipsFavorite({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postClipsUnfavorite(client, request) {
     return Clip.postClipsUnfavorite({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -2986,183 +2491,152 @@ export const Clip = {
   },
 };
 
-
 export const Drive = {
-
   async postDrive(client) {
     return Drive.postDrive({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFiles(client, request) {
     return Drive.postDriveFiles({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesAttachedNotes(client, request) {
     return Drive.postDriveFilesAttachedNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesCheckExistence(client, request) {
     return Drive.postDriveFilesCheckExistence({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesCreate(client, request) {
     return Drive.postDriveFilesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesDelete(client, request) {
     return Drive.postDriveFilesDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesFind(client, request) {
     return Drive.postDriveFilesFind({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesFindByHash(client, request) {
     return Drive.postDriveFilesFindByHash({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesShow(client, request) {
     return Drive.postDriveFilesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesUpdate(client, request) {
     return Drive.postDriveFilesUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesUploadFromUrl(client, request) {
     return Drive.postDriveFilesUploadFromUrl({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFolders(client, request) {
     return Drive.postDriveFolders({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersCreate(client, request) {
     return Drive.postDriveFoldersCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersDelete(client, request) {
     return Drive.postDriveFoldersDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersFind(client, request) {
     return Drive.postDriveFoldersFind({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersShow(client, request) {
     return Drive.postDriveFoldersShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersUpdate(client, request) {
     return Drive.postDriveFoldersUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveStream(client, request) {
     return Drive.postDriveStream({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFiles(client, request) {
     return Drive.postDriveFiles({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesAttachedChatMessages(client, request) {
     return Drive.postDriveFilesAttachedChatMessages({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesAttachedNotes(client, request) {
     return Drive.postDriveFilesAttachedNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesCreate(client, request) {
     return Drive.postDriveFilesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesMoveBulk(client, request) {
     return Drive.postDriveFilesMoveBulk({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesShow(client, request) {
     return Drive.postDriveFilesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFilesUpdate(client, request) {
     return Drive.postDriveFilesUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFolders(client, request) {
     return Drive.postDriveFolders({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersCreate(client, request) {
     return Drive.postDriveFoldersCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersShow(client, request) {
     return Drive.postDriveFoldersShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveFoldersUpdate(client, request) {
     return Drive.postDriveFoldersUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postDriveStream(client, request) {
     return Drive.postDriveStream({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3170,243 +2644,202 @@ export const Drive = {
   },
 };
 
-
 export const Users = {
-
   async postEmailAddressAvailable(client, request) {
     return Users.postEmailAddressAvailable({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGetAvatarDecorations(client) {
     return Users.postGetAvatarDecorations({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postIMove(client, request) {
     return Users.postIMove({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPinnedUsers(client) {
     return Users.postPinnedUsers({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getRetention(client) {
     return Users.getRetention({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRetention(client) {
     return Users.postRetention({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsernameAvailable(client, request) {
     return Users.postUsernameAvailable({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsers(client, request) {
     return Users.postUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersClips(client, request) {
     return Users.postUsersClips({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersFlashs(client, request) {
     return Users.postUsersFlashs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersFollowers(client, request) {
     return Users.postUsersFollowers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersFollowing(client, request) {
     return Users.postUsersFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGalleryPosts(client, request) {
     return Users.postUsersGalleryPosts({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGetFollowingBirthdayUsers(client, request) {
     return Users.postUsersGetFollowingBirthdayUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGetFrequentlyRepliedUsers(client, request) {
     return Users.postUsersGetFrequentlyRepliedUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGetSecurityInfo(client, request) {
     return Users.postUsersGetSecurityInfo({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getUsersGetSkebStatus(client, request) {
     return Users.getUsersGetSkebStatus({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGetSkebStatus(client, request) {
     return Users.postUsersGetSkebStatus({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersNotes(client, request) {
     return Users.postUsersNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersPages(client, request) {
     return Users.postUsersPages({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersReactions(client, request) {
     return Users.postUsersReactions({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersRecommendation(client, request) {
     return Users.postUsersRecommendation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersRelation(client, request) {
     return Users.postUsersRelation({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersReportAbuse(client, request) {
     return Users.postUsersReportAbuse({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersSearch(client, request) {
     return Users.postUsersSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersSearchByUsernameAndHost(client, request) {
     return Users.postUsersSearchByUsernameAndHost({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersShow(client, request) {
     return Users.postUsersShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersStats(client, request) {
     return Users.postUsersStats({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsers(client, request) {
     return Users.postUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersClips(client, request) {
     return Users.postUsersClips({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersFlashs(client, request) {
     return Users.postUsersFlashs({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersFollowers(client, request) {
     return Users.postUsersFollowers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersFollowing(client, request) {
     return Users.postUsersFollowing({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGalleryPosts(client, request) {
     return Users.postUsersGalleryPosts({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersNotes(client, request) {
     return Users.postUsersNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersPages(client, request) {
     return Users.postUsersPages({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersReportAbuse(client, request) {
     return Users.postUsersReportAbuse({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersSearchByUsernameAndHost(client, request) {
     return Users.postUsersSearchByUsernameAndHost({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersShow(client, request) {
     return Users.postUsersShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersTranslate(client, request) {
     return Users.postUsersTranslate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3414,51 +2847,42 @@ export const Users = {
   },
 };
 
-
 export const Flash = {
-
   async postFlashCreate(client, request) {
     return Flash.postFlashCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashFeatured(client, request) {
     return Flash.postFlashFeatured({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashLike(client, request) {
     return Flash.postFlashLike({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashUnlike(client, request) {
     return Flash.postFlashUnlike({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashUpdate(client, request) {
     return Flash.postFlashUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashCreate(client, request) {
     return Flash.postFlashCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashGenToken(client, request) {
     return Flash.postFlashGenToken({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashSearch(client, request) {
     return Flash.postFlashSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3466,21 +2890,17 @@ export const Flash = {
   },
 };
 
-
 export const Flashs = {
-
   async postFlashDelete(client, request) {
     return Flashs.postFlashDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashShow(client, request) {
     return Flashs.postFlashShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFlashShow(client, request) {
     return Flashs.postFlashShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3488,105 +2908,87 @@ export const Flashs = {
   },
 };
 
-
 export const Following = {
-
   async postFollowingCreate(client, request) {
     return Following.postFollowingCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingDelete(client, request) {
     return Following.postFollowingDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingInvalidate(client, request) {
     return Following.postFollowingInvalidate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsAccept(client, request) {
     return Following.postFollowingRequestsAccept({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsCancel(client, request) {
     return Following.postFollowingRequestsCancel({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsList(client, request) {
     return Following.postFollowingRequestsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsReject(client, request) {
     return Following.postFollowingRequestsReject({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsSent(client, request) {
     return Following.postFollowingRequestsSent({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingUpdate(client, request) {
     return Following.postFollowingUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingUpdateAll(client, request) {
     return Following.postFollowingUpdateAll({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingCreate(client, request) {
     return Following.postFollowingCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingDelete(client, request) {
     return Following.postFollowingDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingInvalidate(client, request) {
     return Following.postFollowingInvalidate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsCancel(client, request) {
     return Following.postFollowingRequestsCancel({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsList(client, request) {
     return Following.postFollowingRequestsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingRequestsSent(client, request) {
     return Following.postFollowingRequestsSent({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postFollowingUpdate(client, request) {
     return Following.postFollowingUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3594,81 +2996,67 @@ export const Following = {
   },
 };
 
-
 export const Gallery = {
-
   async postGalleryFeatured(client, request) {
     return Gallery.postGalleryFeatured({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPopular(client) {
     return Gallery.postGalleryPopular({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPosts(client, request) {
     return Gallery.postGalleryPosts({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsCreate(client, request) {
     return Gallery.postGalleryPostsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsDelete(client, request) {
     return Gallery.postGalleryPostsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsLike(client, request) {
     return Gallery.postGalleryPostsLike({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsShow(client, request) {
     return Gallery.postGalleryPostsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsUnlike(client, request) {
     return Gallery.postGalleryPostsUnlike({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsUpdate(client, request) {
     return Gallery.postGalleryPostsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPosts(client, request) {
     return Gallery.postGalleryPosts({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsCreate(client, request) {
     return Gallery.postGalleryPostsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsShow(client, request) {
     return Gallery.postGalleryPostsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postGalleryPostsUpdate(client, request) {
     return Gallery.postGalleryPostsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3676,51 +3064,42 @@ export const Gallery = {
   },
 };
 
-
 export const Hashtags = {
-
   async postHashtagsList(client, request) {
     return Hashtags.postHashtagsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postHashtagsSearch(client, request) {
     return Hashtags.postHashtagsSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postHashtagsShow(client, request) {
     return Hashtags.postHashtagsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async getHashtagsTrend(client) {
     return Hashtags.getHashtagsTrend({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postHashtagsTrend(client) {
     return Hashtags.postHashtagsTrend({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postHashtagsUsers(client, request) {
     return Hashtags.postHashtagsUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postHashtagsShow(client, request) {
     return Hashtags.postHashtagsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postHashtagsUsers(client, request) {
     return Hashtags.postHashtagsUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3728,15 +3107,12 @@ export const Hashtags = {
   },
 };
 
-
 export const Reactions = {
-
   async postNotesReactionsCreate(client, request) {
     return Reactions.postNotesReactionsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotesReactionsDelete(client, request) {
     return Reactions.postNotesReactionsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3744,33 +3120,27 @@ export const Reactions = {
   },
 };
 
-
 export const Notifications = {
-
   async postNotificationsCreate(client, request) {
     return Notifications.postNotificationsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotificationsFlush(client) {
     return Notifications.postNotificationsFlush({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotificationsMarkAllAsRead(client) {
     return Notifications.postNotificationsMarkAllAsRead({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotificationsTestNotification(client) {
     return Notifications.postNotificationsTestNotification({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postNotificationsCreate(client, request) {
     return Notifications.postNotificationsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3778,63 +3148,52 @@ export const Notifications = {
   },
 };
 
-
 export const Pages = {
-
   async postPagesCreate(client, request) {
     return Pages.postPagesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesDelete(client, request) {
     return Pages.postPagesDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesFeatured(client) {
     return Pages.postPagesFeatured({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesLike(client, request) {
     return Pages.postPagesLike({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesShow(client, request) {
     return Pages.postPagesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesUnlike(client, request) {
     return Pages.postPagesUnlike({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesUpdate(client, request) {
     return Pages.postPagesUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesCreate(client, request) {
     return Pages.postPagesCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesShow(client, request) {
     return Pages.postPagesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postPagesUpdate(client, request) {
     return Pages.postPagesUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3842,15 +3201,12 @@ export const Pages = {
   },
 };
 
-
 export const ResetPassword = {
-
   async postRequestResetPassword(client, request) {
     return ResetPassword.postRequestResetPassword({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postResetPassword(client, request) {
     return ResetPassword.postResetPassword({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3858,15 +3214,12 @@ export const ResetPassword = {
   },
 };
 
-
 export const NonProductive = {
-
   async postResetDb(client) {
     return NonProductive.postResetDb({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postTest(client, request) {
     return NonProductive.postTest({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3874,45 +3227,37 @@ export const NonProductive = {
   },
 };
 
-
 export const Role = {
-
   async postRolesList(client) {
     return Role.postRolesList({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRolesNotes(client, request) {
     return Role.postRolesNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRolesShow(client, request) {
     return Role.postRolesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRolesUsers(client, request) {
     return Role.postRolesUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRolesNotes(client, request) {
     return Role.postRolesNotes({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRolesShow(client, request) {
     return Role.postRolesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postRolesUsers(client, request) {
     return Role.postRolesUsers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3920,75 +3265,62 @@ export const Role = {
   },
 };
 
-
 export const Lists = {
-
   async postUsersListsCreate(client, request) {
     return Lists.postUsersListsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsDelete(client, request) {
     return Lists.postUsersListsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsGetMemberships(client, request) {
     return Lists.postUsersListsGetMemberships({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsList(client, request) {
     return Lists.postUsersListsList({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsPull(client, request) {
     return Lists.postUsersListsPull({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsPush(client, request) {
     return Lists.postUsersListsPush({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsShow(client, request) {
     return Lists.postUsersListsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsUpdate(client, request) {
     return Lists.postUsersListsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsUpdateMembership(client, request) {
     return Lists.postUsersListsUpdateMembership({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsCreate(client, request) {
     return Lists.postUsersListsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsGetMemberships(client, request) {
     return Lists.postUsersListsGetMemberships({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersListsUpdate(client, request) {
     return Lists.postUsersListsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -3996,165 +3328,137 @@ export const Lists = {
   },
 };
 
-
 export const Chat = {
-
   async postChatHistory(client, request) {
     return Chat.postChatHistory({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesCreateToRoom(client, request) {
     return Chat.postChatMessagesCreateToRoom({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesCreateToUser(client, request) {
     return Chat.postChatMessagesCreateToUser({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesDelete(client, request) {
     return Chat.postChatMessagesDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesReact(client, request) {
     return Chat.postChatMessagesReact({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesRoomTimeline(client, request) {
     return Chat.postChatMessagesRoomTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesSearch(client, request) {
     return Chat.postChatMessagesSearch({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesShow(client, request) {
     return Chat.postChatMessagesShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesUnreact(client, request) {
     return Chat.postChatMessagesUnreact({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatMessagesUserTimeline(client, request) {
     return Chat.postChatMessagesUserTimeline({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatReadAll(client) {
     return Chat.postChatReadAll({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsCreate(client, request) {
     return Chat.postChatRoomsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsDelete(client, request) {
     return Chat.postChatRoomsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsInvitationsCancel(client, request) {
     return Chat.postChatRoomsInvitationsCancel({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsInvitationsCreate(client, request) {
     return Chat.postChatRoomsInvitationsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsInvitationsIgnore(client, request) {
     return Chat.postChatRoomsInvitationsIgnore({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsInvitationsInbox(client, request) {
     return Chat.postChatRoomsInvitationsInbox({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsInvitationsOutbox(client, request) {
     return Chat.postChatRoomsInvitationsOutbox({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsInvitationsReject(client, request) {
     return Chat.postChatRoomsInvitationsReject({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsJoin(client, request) {
     return Chat.postChatRoomsJoin({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsJoining(client, request) {
     return Chat.postChatRoomsJoining({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsLeave(client, request) {
     return Chat.postChatRoomsLeave({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsMembers(client, request) {
     return Chat.postChatRoomsMembers({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsMute(client, request) {
     return Chat.postChatRoomsMute({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsOwned(client, request) {
     return Chat.postChatRoomsOwned({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsShow(client, request) {
     return Chat.postChatRoomsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postChatRoomsUpdate(client, request) {
     return Chat.postChatRoomsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
@@ -4162,78 +3466,66 @@ export const Chat = {
   },
 };
 
-
 export const Groups = {
-
   async postUsersGroupsCreate(client, request) {
     return Groups.postUsersGroupsCreate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsDelete(client, request) {
     return Groups.postUsersGroupsDelete({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsInvitationsAccept(client, request) {
     return Groups.postUsersGroupsInvitationsAccept({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsInvitationsReject(client, request) {
     return Groups.postUsersGroupsInvitationsReject({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsInvite(client, request) {
     return Groups.postUsersGroupsInvite({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsJoined(client) {
     return Groups.postUsersGroupsJoined({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsLeave(client, request) {
     return Groups.postUsersGroupsLeave({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsOwned(client) {
     return Groups.postUsersGroupsOwned({
       fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsPull(client, request) {
     return Groups.postUsersGroupsPull({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsShow(client, request) {
     return Groups.postUsersGroupsShow({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsTransfer(client, request) {
     return Groups.postUsersGroupsTransfer({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-
   async postUsersGroupsUpdate(client, request) {
     return Groups.postUsersGroupsUpdate({
       body: request, fetch: (url, method, body) => client._fetch(url, method, body)
     });
   },
-};
+};
+