fusio-sdk 3.0.4 → 3.0.6

package/dist/src/generated/consumer/GrantTag.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 GrantTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async delete(grantId) {
@@ -26,6 +28,14 @@ export class GrantTag 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,19 @@ export class GrantTag extends TagAbstract {
     }
     /**
      * @returns {Promise<GrantCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/consumer/grant', {});
         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);
@@ -51,6 +66,10 @@ export class GrantTag 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/consumer/LogTag.d.ts

@@ -8,12 +8,14 @@ import { LogCollection } from "./LogCollection";
 export declare class LogTag extends TagAbstract {
     /**
      * @returns {Promise<Log>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(logId: string): Promise<Log>;
     /**
      * @returns {Promise<LogCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<LogCollection>;
+    getAll(startIndex?: number, count?: number, search?: string): Promise<LogCollection>;
 }

package/dist/src/generated/consumer/LogTag.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 LogTag extends TagAbstract {
     /**
      * @returns {Promise<Log>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(logId) {
@@ -26,6 +28,14 @@ export class LogTag 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,19 @@ export class LogTag extends TagAbstract {
     }
     /**
      * @returns {Promise<LogCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/consumer/log', {});
         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);
@@ -51,6 +66,10 @@ export class LogTag 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/consumer/MessageException.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MessageException automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { KnownStatusCodeException } from "sdkgen-client";
+import { Message } from "./Message";
+export declare class MessageException extends KnownStatusCodeException {
+    private payload;
+    constructor(payload: Message);
+    getPayload(): Message;
+}

package/dist/src/generated/consumer/MessageException.js

@@ -0,0 +1,14 @@
+/**
+ * MessageException automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { KnownStatusCodeException } from "sdkgen-client";
+export class MessageException extends KnownStatusCodeException {
+    constructor(payload) {
+        super();
+        this.payload = payload;
+    }
+    getPayload() {
+        return this.payload;
+    }
+}

package/dist/src/generated/consumer/PageTag.d.ts

@@ -8,12 +8,14 @@ import { PageCollection } from "./PageCollection";
 export declare class PageTag extends TagAbstract {
     /**
      * @returns {Promise<Page>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(pageId: string): Promise<Page>;
     /**
      * @returns {Promise<PageCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<PageCollection>;
+    getAll(startIndex?: number, count?: number, search?: string): Promise<PageCollection>;
 }

package/dist/src/generated/consumer/PageTag.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 PageTag extends TagAbstract {
     /**
      * @returns {Promise<Page>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(pageId) {
@@ -26,6 +28,14 @@ export class PageTag 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,19 @@ export class PageTag extends TagAbstract {
     }
     /**
      * @returns {Promise<PageCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/consumer/page', {});
         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);
@@ -51,6 +66,10 @@ export class PageTag 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/consumer/PaymentTag.d.ts

@@ -10,11 +10,13 @@ import { PaymentPortalResponse } from "./PaymentPortalResponse";
 export declare class PaymentTag extends TagAbstract {
     /**
      * @returns {Promise<PaymentCheckoutResponse>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     checkout(provider: string, payload: PaymentCheckoutRequest): Promise<PaymentCheckoutResponse>;
     /**
      * @returns {Promise<PaymentPortalResponse>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     portal(provider: string, payload: PaymentPortalRequest): Promise<PaymentPortalResponse>;

package/dist/src/generated/consumer/PaymentTag.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 PaymentTag extends TagAbstract {
     /**
      * @returns {Promise<PaymentCheckoutResponse>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async checkout(provider, payload) {
@@ -27,6 +29,10 @@ export class PaymentTag 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');
                 }
@@ -36,6 +42,7 @@ export class PaymentTag extends TagAbstract {
     }
     /**
      * @returns {Promise<PaymentPortalResponse>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async portal(provider, payload) {
@@ -55,6 +62,10 @@ export class PaymentTag 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/consumer/PlanTag.d.ts

@@ -8,12 +8,14 @@ import { PlanCollection } from "./PlanCollection";
 export declare class PlanTag extends TagAbstract {
     /**
      * @returns {Promise<Plan>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(planId: string): Promise<Plan>;
     /**
      * @returns {Promise<PlanCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<PlanCollection>;
+    getAll(startIndex?: number, count?: number, search?: string): Promise<PlanCollection>;
 }

package/dist/src/generated/consumer/PlanTag.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 PlanTag extends TagAbstract {
     /**
      * @returns {Promise<Plan>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(planId) {
@@ -26,6 +28,14 @@ export class PlanTag 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,19 @@ export class PlanTag extends TagAbstract {
     }
     /**
      * @returns {Promise<PlanCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/consumer/plan', {});
         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);
@@ -51,6 +66,10 @@ export class PlanTag 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/consumer/ScopeTag.d.ts

@@ -7,7 +7,8 @@ import { ScopeCollection } from "./ScopeCollection";
 export declare class ScopeTag extends TagAbstract {
     /**
      * @returns {Promise<ScopeCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<ScopeCollection>;
+    getAll(startIndex?: number, count?: number, search?: string): Promise<ScopeCollection>;
 }

package/dist/src/generated/consumer/ScopeTag.js

@@ -5,17 +5,23 @@
 import axios from "axios";
 import { TagAbstract } from "sdkgen-client";
 import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+import { MessageException } from "./MessageException";
 export class ScopeTag extends TagAbstract {
     /**
      * @returns {Promise<ScopeCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/consumer/scope', {});
         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);
@@ -24,6 +30,10 @@ export class ScopeTag 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/consumer/SubscriptionTag.d.ts

@@ -11,27 +11,32 @@ import { Message } from "./Message";
 export declare class SubscriptionTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     delete(subscriptionId: string): Promise<Message>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     update(subscriptionId: string, payload: EventSubscriptionUpdate): Promise<Message>;
     /**
      * @returns {Promise<EventSubscription>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(subscriptionId: string): Promise<EventSubscription>;
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     create(payload: EventSubscriptionCreate): Promise<Message>;
     /**
      * @returns {Promise<EventSubscriptionCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<EventSubscriptionCollection>;
+    getAll(startIndex?: number, count?: number, search?: string): Promise<EventSubscriptionCollection>;
 }

package/dist/src/generated/consumer/SubscriptionTag.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 SubscriptionTag extends TagAbstract {
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async delete(subscriptionId) {
@@ -26,6 +28,14 @@ export class SubscriptionTag 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,6 +45,7 @@ export class SubscriptionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async update(subscriptionId, payload) {
@@ -54,6 +65,16 @@ export class SubscriptionTag 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 SubscriptionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<EventSubscription>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(subscriptionId) {
@@ -81,6 +103,14 @@ export class SubscriptionTag 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 SubscriptionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<Message>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async create(payload) {
@@ -107,6 +138,12 @@ export class SubscriptionTag 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');
                 }
@@ -116,14 +153,19 @@ export class SubscriptionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<EventSubscriptionCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/consumer/subscription', {});
         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);
@@ -132,6 +174,10 @@ export class SubscriptionTag 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/consumer/TransactionTag.d.ts

@@ -8,12 +8,14 @@ import { TransactionCollection } from "./TransactionCollection";
 export declare class TransactionTag extends TagAbstract {
     /**
      * @returns {Promise<Transaction>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     get(transactionId: string): Promise<Transaction>;
     /**
      * @returns {Promise<TransactionCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    getAll(): Promise<TransactionCollection>;
+    getAll(startIndex?: number, count?: number, search?: string): Promise<TransactionCollection>;
 }

package/dist/src/generated/consumer/TransactionTag.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 TransactionTag extends TagAbstract {
     /**
      * @returns {Promise<Transaction>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
     async get(transactionId) {
@@ -26,6 +28,14 @@ export class TransactionTag 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,19 @@ export class TransactionTag extends TagAbstract {
     }
     /**
      * @returns {Promise<TransactionCollection>}
+     * @throws {MessageException}
      * @throws {ClientException}
      */
-    async getAll() {
+    async getAll(startIndex, count, search) {
         const url = this.parser.url('/consumer/transaction', {});
         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);
@@ -51,6 +66,10 @@ export class TransactionTag 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fusio-sdk",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "description": "SDK to talk to the Fusio API",
   "keywords": [
     "API",