fusio-sdk 3.0.4 → 3.0.6

package/dist/src/generated/backend/AccountTag.d.ts

@@ -10,16 +10,19 @@ import { UserUpdate } from "./UserUpdate";
 export declare class AccountTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     changePassword(payload: AccountChangePassword): Promise<Message>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     update(payload: UserUpdate): Promise<Message>;
     /**
      * @returns {Promise<User>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(): Promise<User>;

package/dist/src/generated/backend/AccountTag.js

@@ -5,9 +5,11 @@
 import axios from "axios";
 import { TagAbstract } from "sdkgen-client";
 import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+import { MessageException } from "./MessageException";
 export class AccountTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async changePassword(payload) {
@@ -25,6 +27,12 @@ export class AccountTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 400:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -34,6 +42,7 @@ export class AccountTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async update(payload) {
@@ -51,6 +60,12 @@ export class AccountTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 400:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -60,6 +75,7 @@ export class AccountTag extends TagAbstract {
     }
     /**
      * @returns {Promise<User>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get() {
@@ -76,6 +92,10 @@ export class AccountTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }

package/dist/src/generated/backend/ActionTag.d.ts

@@ -15,42 +15,50 @@ import { Message } from "./Message";
 export declare class ActionTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     delete(actionId: string): Promise<Message>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     update(actionId: string, payload: ActionUpdate): Promise<Message>;
     /**
      * @returns {Promise<Action>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(actionId: string): Promise<Action>;
     /**
      * @returns {Promise<ActionExecuteResponse>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     execute(actionId: string, payload: ActionExecuteRequest): Promise<ActionExecuteResponse>;
     /**
      * @returns {Promise<FormContainer>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getForm(): Promise<FormContainer>;
+    getForm(_class?: string): Promise<FormContainer>;
     /**
      * @returns {Promise<ActionIndex>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     getClasses(): Promise<ActionIndex>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     create(payload: ActionCreate): Promise<Message>;
     /**
      * @returns {Promise<ActionCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<ActionCollection>;
+    getAll(startIndex?: number, count?: number, categoryId?: number): Promise<ActionCollection>;
 }

package/dist/src/generated/backend/ActionTag.js

@@ -5,9 +5,11 @@
 import axios from "axios";
 import { TagAbstract } from "sdkgen-client";
 import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+import { MessageException } from "./MessageException";
 export class ActionTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async delete(actionId) {
@@ -26,6 +28,14 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -35,6 +45,7 @@ export class ActionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async update(actionId, payload) {
@@ -54,6 +65,16 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 400:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -63,6 +84,7 @@ export class ActionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Action>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(actionId) {
@@ -81,6 +103,14 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -90,6 +120,7 @@ export class ActionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<ActionExecuteResponse>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async execute(actionId, payload) {
@@ -109,6 +140,10 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -118,14 +153,17 @@ export class ActionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<FormContainer>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getForm() {
+    async getForm(_class) {
         const url = this.parser.url('/backend/action/form', {});
         let params = {
             url: url,
             method: 'GET',
-            params: this.parser.query({}),
+            params: this.parser.query({
+                'class': _class,
+            }),
         };
         try {
             const response = await this.httpClient.request(params);
@@ -134,6 +172,10 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -143,6 +185,7 @@ export class ActionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<ActionIndex>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async getClasses() {
@@ -159,6 +202,10 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -168,6 +215,7 @@ export class ActionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async create(payload) {
@@ -185,6 +233,12 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 400:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -194,14 +248,19 @@ export class ActionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<ActionCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, categoryId) {
         const url = this.parser.url('/backend/action', {});
         let params = {
             url: url,
             method: 'GET',
-            params: this.parser.query({}),
+            params: this.parser.query({
+                'startIndex': startIndex,
+                'count': count,
+                'categoryId': categoryId,
+            }),
         };
         try {
             const response = await this.httpClient.request(params);
@@ -210,6 +269,10 @@ export class ActionTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }

package/dist/src/generated/backend/AppTag.d.ts

@@ -13,42 +13,50 @@ import { Message } from "./Message";
 export declare class AppTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     deleteToken(appId: string, tokenId: string): Promise<Message>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     delete(appId: string): Promise<Message>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     update(appId: string, payload: AppUpdate): Promise<Message>;
     /**
      * @returns {Promise<App>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(appId: string): Promise<App>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     create(payload: AppCreate): Promise<Message>;
     /**
      * @returns {Promise<AppCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<AppCollection>;
+    getAll(startIndex?: number, count?: number, search?: string): Promise<AppCollection>;
     /**
      * @returns {Promise<AppToken>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     getToken(tokenId: string): Promise<AppToken>;
     /**
      * @returns {Promise<AppTokenCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAllTokens(): Promise<AppTokenCollection>;
+    getAllTokens(startIndex?: number, count?: number, search?: string, from?: string, to?: string, appId?: number, userId?: number, status?: number, scope?: string, ip?: string): Promise<AppTokenCollection>;
 }

package/dist/src/generated/backend/AppTag.js

@@ -5,9 +5,11 @@
 import axios from "axios";
 import { TagAbstract } from "sdkgen-client";
 import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+import { MessageException } from "./MessageException";
 export class AppTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async deleteToken(appId, tokenId) {
@@ -27,6 +29,14 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -36,6 +46,7 @@ export class AppTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async delete(appId) {
@@ -54,6 +65,14 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -63,6 +82,7 @@ export class AppTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async update(appId, payload) {
@@ -82,6 +102,16 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 400:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -91,6 +121,7 @@ export class AppTag extends TagAbstract {
     }
     /**
      * @returns {Promise<App>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(appId) {
@@ -109,6 +140,14 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -118,6 +157,7 @@ export class AppTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async create(payload) {
@@ -135,6 +175,12 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 400:
+                        throw new MessageException(error.response.data);
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -144,14 +190,19 @@ export class AppTag extends TagAbstract {
     }
     /**
      * @returns {Promise<AppCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/backend/app', {});
         let params = {
             url: url,
             method: 'GET',
-            params: this.parser.query({}),
+            params: this.parser.query({
+                'startIndex': startIndex,
+                'count': count,
+                'search': search,
+            }),
         };
         try {
             const response = await this.httpClient.request(params);
@@ -160,6 +211,10 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -169,6 +224,7 @@ export class AppTag extends TagAbstract {
     }
     /**
      * @returns {Promise<AppToken>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async getToken(tokenId) {
@@ -187,6 +243,12 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -196,14 +258,26 @@ export class AppTag extends TagAbstract {
     }
     /**
      * @returns {Promise<AppTokenCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAllTokens() {
+    async getAllTokens(startIndex, count, search, from, to, appId, userId, status, scope, ip) {
         const url = this.parser.url('/backend/app/token', {});
         let params = {
             url: url,
             method: 'GET',
-            params: this.parser.query({}),
+            params: this.parser.query({
+                'startIndex': startIndex,
+                'count': count,
+                'search': search,
+                'from': from,
+                'to': to,
+                'appId': appId,
+                'userId': userId,
+                'status': status,
+                'scope': scope,
+                'ip': ip,
+            }),
         };
         try {
             const response = await this.httpClient.request(params);
@@ -212,6 +286,10 @@ export class AppTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }

package/dist/src/generated/backend/AuditTag.d.ts

@@ -8,12 +8,14 @@ import { AuditCollection } from "./AuditCollection";
 export declare class AuditTag extends TagAbstract {
     /**
      * @returns {Promise<Audit>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(auditId: string): Promise<Audit>;
     /**
      * @returns {Promise<AuditCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<AuditCollection>;
+    getAll(startIndex?: number, count?: number, search?: string, from?: string, to?: string, appId?: number, userId?: number, event?: string, ip?: string, message?: string): Promise<AuditCollection>;
 }

package/dist/src/generated/backend/AuditTag.js

@@ -5,9 +5,11 @@
 import axios from "axios";
 import { TagAbstract } from "sdkgen-client";
 import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+import { MessageException } from "./MessageException";
 export class AuditTag extends TagAbstract {
     /**
      * @returns {Promise<Audit>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(auditId) {
@@ -26,6 +28,14 @@ export class AuditTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 404:
+                        throw new MessageException(error.response.data);
+                    case 410:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }
@@ -35,14 +45,26 @@ export class AuditTag extends TagAbstract {
     }
     /**
      * @returns {Promise<AuditCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search, from, to, appId, userId, event, ip, message) {
         const url = this.parser.url('/backend/audit', {});
         let params = {
             url: url,
             method: 'GET',
-            params: this.parser.query({}),
+            params: this.parser.query({
+                'startIndex': startIndex,
+                'count': count,
+                'search': search,
+                'from': from,
+                'to': to,
+                'appId': appId,
+                'userId': userId,
+                'event': event,
+                'ip': ip,
+                'message': message,
+            }),
         };
         try {
             const response = await this.httpClient.request(params);
@@ -51,6 +73,10 @@ export class AuditTag extends TagAbstract {
         catch (error) {
             if (axios.isAxiosError(error) && error.response) {
                 switch (error.response.status) {
+                    case 401:
+                        throw new MessageException(error.response.data);
+                    case 500:
+                        throw new MessageException(error.response.data);
                     default:
                         throw new UnknownStatusCodeException('The server returned an unknown status code');
                 }