@f3liz/rescript-misskey-api 0.6.7 → 0.6.9

package/src/generated/misskey-io/wrapper/index.mjs

@@ -27,7 +27,6 @@ import * as ResetPassword from '../../generated/misskey-io/ResetPassword.mjs';
 import * as NonProductive from '../../generated/misskey-io/NonProductive.mjs';
 import * as Role from '../../generated/misskey-io/Role.mjs';
 import * as Lists from '../../generated/misskey-io/Lists.mjs';
-
 export class MisskeyClient {
   constructor(baseUrl, token) {
     this.baseUrl = baseUrl;
@@ -48,645 +47,537 @@ 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)
@@ -694,333 +585,277 @@ 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)
@@ -1028,147 +863,122 @@ 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)
@@ -1176,45 +986,37 @@ 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)
@@ -1222,39 +1024,32 @@ 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)
@@ -1262,69 +1057,57 @@ 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)
@@ -1332,15 +1115,12 @@ 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)
@@ -1348,33 +1128,27 @@ 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)
@@ -1382,207 +1156,172 @@ 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)
@@ -1590,81 +1329,67 @@ 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)
@@ -1672,213 +1397,177 @@ 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)
@@ -1886,147 +1575,122 @@ 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)
@@ -2034,39 +1698,32 @@ 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)
@@ -2074,15 +1731,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)
@@ -2090,111 +1744,92 @@ 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)
@@ -2202,171 +1837,142 @@ 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)
@@ -2374,33 +1980,27 @@ 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)
@@ -2408,15 +2008,12 @@ 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)
@@ -2424,63 +2021,52 @@ 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)
@@ -2488,57 +2074,47 @@ 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)
@@ -2546,39 +2122,32 @@ 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)
@@ -2586,15 +2155,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)
@@ -2602,27 +2168,22 @@ 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)
@@ -2630,45 +2191,37 @@ 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)
@@ -2676,15 +2229,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)
@@ -2692,15 +2242,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)
@@ -2708,27 +2255,22 @@ 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)
@@ -2736,60 +2278,51 @@ 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)
     });
   },
-};
+};
+