fusio-sdk 3.0.3 → 3.0.5

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

@@ -0,0 +1,34 @@
+/**
+ * DashboardTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import axios from "axios";
+import { TagAbstract } from "sdkgen-client";
+import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+export class DashboardTag extends TagAbstract {
+    /**
+     * @returns {Promise<Dashboard>}
+     * @throws {ClientException}
+     */
+    async getAll() {
+        const url = this.parser.url('/backend/dashboard', {});
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({}),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+/**
+ * EventTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { Event } from "./Event";
+import { EventCollection } from "./EventCollection";
+import { EventCreate } from "./EventCreate";
+import { EventSubscription } from "./EventSubscription";
+import { EventSubscriptionCollection } from "./EventSubscriptionCollection";
+import { EventSubscriptionCreate } from "./EventSubscriptionCreate";
+import { EventSubscriptionUpdate } from "./EventSubscriptionUpdate";
+import { EventUpdate } from "./EventUpdate";
+import { Message } from "./Message";
+export declare class EventTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    delete(eventId: string): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    update(eventId: string, payload: EventUpdate): Promise<Message>;
+    /**
+     * @returns {Promise<Event>}
+     * @throws {ClientException}
+     */
+    get(eventId: string): Promise<Event>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    create(payload: EventCreate): Promise<Message>;
+    /**
+     * @returns {Promise<EventCollection>}
+     * @throws {ClientException}
+     */
+    getAll(categoryId?: number, startIndex?: number, count?: number, search?: string): Promise<EventCollection>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    deleteSubscription(subscriptionId: string): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    updateSubscription(subscriptionId: string, payload: EventSubscriptionUpdate): Promise<Message>;
+    /**
+     * @returns {Promise<EventSubscription>}
+     * @throws {ClientException}
+     */
+    getSubscription(subscriptionId: string): Promise<EventSubscription>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    createSubscription(payload: EventSubscriptionCreate): Promise<Message>;
+    /**
+     * @returns {Promise<EventSubscriptionCollection>}
+     * @throws {ClientException}
+     */
+    getAllSubscriptions(startIndex?: number, count?: number, search?: string): Promise<EventSubscriptionCollection>;
+}

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

@@ -0,0 +1,284 @@
+/**
+ * EventTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import axios from "axios";
+import { TagAbstract } from "sdkgen-client";
+import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+export class EventTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async delete(eventId) {
+        const url = this.parser.url('/backend/event/$event_id<[0-9]+|^~>', {
+            'event_id': eventId,
+        });
+        let params = {
+            url: url,
+            method: 'DELETE',
+            params: this.parser.query({}),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async update(eventId, payload) {
+        const url = this.parser.url('/backend/event/$event_id<[0-9]+|^~>', {
+            'event_id': eventId,
+        });
+        let params = {
+            url: url,
+            method: 'PUT',
+            params: this.parser.query({}),
+            data: payload
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<Event>}
+     * @throws {ClientException}
+     */
+    async get(eventId) {
+        const url = this.parser.url('/backend/event/$event_id<[0-9]+|^~>', {
+            'event_id': eventId,
+        });
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({}),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async create(payload) {
+        const url = this.parser.url('/backend/event', {});
+        let params = {
+            url: url,
+            method: 'POST',
+            params: this.parser.query({}),
+            data: payload
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<EventCollection>}
+     * @throws {ClientException}
+     */
+    async getAll(categoryId, startIndex, count, search) {
+        const url = this.parser.url('/backend/event', {});
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({
+                'categoryId': categoryId,
+                'startIndex': startIndex,
+                'count': count,
+                'search': search,
+            }),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async deleteSubscription(subscriptionId) {
+        const url = this.parser.url('/backend/event/subscription/$subscription_id<[0-9]+>', {
+            'subscription_id': subscriptionId,
+        });
+        let params = {
+            url: url,
+            method: 'DELETE',
+            params: this.parser.query({}),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async updateSubscription(subscriptionId, payload) {
+        const url = this.parser.url('/backend/event/subscription/$subscription_id<[0-9]+>', {
+            'subscription_id': subscriptionId,
+        });
+        let params = {
+            url: url,
+            method: 'PUT',
+            params: this.parser.query({}),
+            data: payload
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<EventSubscription>}
+     * @throws {ClientException}
+     */
+    async getSubscription(subscriptionId) {
+        const url = this.parser.url('/backend/event/subscription/$subscription_id<[0-9]+>', {
+            'subscription_id': subscriptionId,
+        });
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({}),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async createSubscription(payload) {
+        const url = this.parser.url('/backend/event/subscription', {});
+        let params = {
+            url: url,
+            method: 'POST',
+            params: this.parser.query({}),
+            data: payload
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<EventSubscriptionCollection>}
+     * @throws {ClientException}
+     */
+    async getAllSubscriptions(startIndex, count, search) {
+        const url = this.parser.url('/backend/event/subscription', {});
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({
+                'startIndex': startIndex,
+                'count': count,
+                'search': search,
+            }),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+}

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

@@ -4,9 +4,9 @@
  */
 import { Schema } from "./Schema";
 import { Action } from "./Action";
-import { Route } from "./Route";
+import { Operation } from "./Operation";
 export interface GeneratorProviderChangelog {
     schemas?: Array<Schema>;
     actions?: Array<Action>;
-    routes?: Array<Route>;
+    operations?: Array<Operation>;
 }

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

@@ -0,0 +1,33 @@
+/**
+ * GeneratorTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { FormContainer } from "./FormContainer";
+import { GeneratorIndexProviders } from "./GeneratorIndexProviders";
+import { GeneratorProvider } from "./GeneratorProvider";
+import { GeneratorProviderChangelog } from "./GeneratorProviderChangelog";
+import { GeneratorProviderConfig } from "./GeneratorProviderConfig";
+import { Message } from "./Message";
+export declare class GeneratorTag extends TagAbstract {
+    /**
+     * @returns {Promise<GeneratorProviderChangelog>}
+     * @throws {ClientException}
+     */
+    getChangelog(provider: string, payload: GeneratorProviderConfig): Promise<GeneratorProviderChangelog>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    executeProvider(provider: string, payload: GeneratorProvider): Promise<Message>;
+    /**
+     * @returns {Promise<FormContainer>}
+     * @throws {ClientException}
+     */
+    getProviderForm(provider: string): Promise<FormContainer>;
+    /**
+     * @returns {Promise<GeneratorIndexProviders>}
+     * @throws {ClientException}
+     */
+    getProviders(): Promise<GeneratorIndexProviders>;
+}

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

@@ -0,0 +1,117 @@
+/**
+ * GeneratorTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import axios from "axios";
+import { TagAbstract } from "sdkgen-client";
+import { ClientException, UnknownStatusCodeException } from "sdkgen-client";
+export class GeneratorTag extends TagAbstract {
+    /**
+     * @returns {Promise<GeneratorProviderChangelog>}
+     * @throws {ClientException}
+     */
+    async getChangelog(provider, payload) {
+        const url = this.parser.url('/backend/generator/:provider', {
+            'provider': provider,
+        });
+        let params = {
+            url: url,
+            method: 'PUT',
+            params: this.parser.query({}),
+            data: payload
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async executeProvider(provider, payload) {
+        const url = this.parser.url('/backend/generator/:provider', {
+            'provider': provider,
+        });
+        let params = {
+            url: url,
+            method: 'POST',
+            params: this.parser.query({}),
+            data: payload
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<FormContainer>}
+     * @throws {ClientException}
+     */
+    async getProviderForm(provider) {
+        const url = this.parser.url('/backend/generator/:provider', {
+            'provider': provider,
+        });
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({}),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+    /**
+     * @returns {Promise<GeneratorIndexProviders>}
+     * @throws {ClientException}
+     */
+    async getProviders() {
+        const url = this.parser.url('/backend/generator', {});
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({}),
+        };
+        try {
+            const response = await this.httpClient.request(params);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response) {
+                switch (error.response.status) {
+                    default:
+                        throw new UnknownStatusCodeException('The server returned an unknown status code');
+                }
+            }
+            throw new ClientException('An unknown error occurred: ' + String(error));
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * LogTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { Log } from "./Log";
+import { LogCollection } from "./LogCollection";
+import { LogError } from "./LogError";
+import { LogErrorCollection } from "./LogErrorCollection";
+export declare class LogTag extends TagAbstract {
+    /**
+     * @returns {Promise<Log>}
+     * @throws {ClientException}
+     */
+    get(logId: string): Promise<Log>;
+    /**
+     * @returns {Promise<LogCollection>}
+     * @throws {ClientException}
+     */
+    getAll(startIndex?: number, count?: number, search?: string, from?: string, to?: string, routeId?: number, appId?: number, userId?: number, ip?: string, userAgent?: string, method?: string, path?: string, header?: string, body?: string): Promise<LogCollection>;
+    /**
+     * @returns {Promise<LogError>}
+     * @throws {ClientException}
+     */
+    getError(errorId: string): Promise<LogError>;
+    /**
+     * @returns {Promise<LogErrorCollection>}
+     * @throws {ClientException}
+     */
+    getAllErrors(startIndex?: number, count?: number, search?: string): Promise<LogErrorCollection>;
+}