fusio-sdk 3.0.3 → 3.0.5

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

@@ -0,0 +1,26 @@
+/**
+ * ConfigTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { Config } from "./Config";
+import { ConfigCollection } from "./ConfigCollection";
+import { ConfigUpdate } from "./ConfigUpdate";
+import { Message } from "./Message";
+export declare class ConfigTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    update(configId: string, payload: ConfigUpdate): Promise<Message>;
+    /**
+     * @returns {Promise<Config>}
+     * @throws {ClientException}
+     */
+    get(configId: string): Promise<Config>;
+    /**
+     * @returns {Promise<ConfigCollection>}
+     * @throws {ClientException}
+     */
+    getAll(startIndex?: number, count?: number, search?: string): Promise<ConfigCollection>;
+}

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

@@ -0,0 +1,93 @@
+/**
+ * ConfigTag 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 ConfigTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async update(configId, payload) {
+        const url = this.parser.url('/backend/config/$config_id<[0-9]+|^~>', {
+            'config_id': configId,
+        });
+        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<Config>}
+     * @throws {ClientException}
+     */
+    async get(configId) {
+        const url = this.parser.url('/backend/config/$config_id<[0-9]+|^~>', {
+            'config_id': configId,
+        });
+        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<ConfigCollection>}
+     * @throws {ClientException}
+     */
+    async getAll(startIndex, count, search) {
+        const url = this.parser.url('/backend/config', {});
+        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/ConnectionTag.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ConnectionTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { Connection } from "./Connection";
+import { ConnectionCollection } from "./ConnectionCollection";
+import { ConnectionCreate } from "./ConnectionCreate";
+import { ConnectionIndex } from "./ConnectionIndex";
+import { ConnectionIntrospectionEntities } from "./ConnectionIntrospectionEntities";
+import { ConnectionIntrospectionEntity } from "./ConnectionIntrospectionEntity";
+import { ConnectionUpdate } from "./ConnectionUpdate";
+import { FormContainer } from "./FormContainer";
+import { Message } from "./Message";
+export declare class ConnectionTag extends TagAbstract {
+    /**
+     * @returns {Promise<ConnectionIntrospectionEntity>}
+     * @throws {ClientException}
+     */
+    getIntrospectionForEntity(connectionId: string, entity: string): Promise<ConnectionIntrospectionEntity>;
+    /**
+     * @returns {Promise<ConnectionIntrospectionEntities>}
+     * @throws {ClientException}
+     */
+    getIntrospection(connectionId: string): Promise<ConnectionIntrospectionEntities>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    getRedirect(connectionId: string): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    delete(connectionId: string): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    update(connectionId: string, payload: ConnectionUpdate): Promise<Message>;
+    /**
+     * @returns {Promise<Connection>}
+     * @throws {ClientException}
+     */
+    get(connectionId: string): Promise<Connection>;
+    /**
+     * @returns {Promise<FormContainer>}
+     * @throws {ClientException}
+     */
+    getForm(_class?: string): Promise<FormContainer>;
+    /**
+     * @returns {Promise<ConnectionIndex>}
+     * @throws {ClientException}
+     */
+    getClasses(): Promise<ConnectionIndex>;
+    /**
+     * @returns {Promise<ConnectionCollection>}
+     * @throws {ClientException}
+     */
+    create(payload: ConnectionCreate): Promise<ConnectionCollection>;
+    /**
+     * @returns {Promise<ConnectionCollection>}
+     * @throws {ClientException}
+     */
+    getAll(startIndex?: number, count?: number, search?: string): Promise<ConnectionCollection>;
+}

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

@@ -0,0 +1,280 @@
+/**
+ * ConnectionTag 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 ConnectionTag extends TagAbstract {
+    /**
+     * @returns {Promise<ConnectionIntrospectionEntity>}
+     * @throws {ClientException}
+     */
+    async getIntrospectionForEntity(connectionId, entity) {
+        const url = this.parser.url('/backend/connection/$connection_id<[0-9]+|^~>/introspection/:entity', {
+            'connection_id': connectionId,
+            'entity': entity,
+        });
+        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<ConnectionIntrospectionEntities>}
+     * @throws {ClientException}
+     */
+    async getIntrospection(connectionId) {
+        const url = this.parser.url('/backend/connection/$connection_id<[0-9]+|^~>/introspection', {
+            'connection_id': connectionId,
+        });
+        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 getRedirect(connectionId) {
+        const url = this.parser.url('/backend/connection/$connection_id<[0-9]+|^~>/redirect', {
+            'connection_id': connectionId,
+        });
+        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 delete(connectionId) {
+        const url = this.parser.url('/backend/connection/$connection_id<[0-9]+|^~>', {
+            'connection_id': connectionId,
+        });
+        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(connectionId, payload) {
+        const url = this.parser.url('/backend/connection/$connection_id<[0-9]+|^~>', {
+            'connection_id': connectionId,
+        });
+        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<Connection>}
+     * @throws {ClientException}
+     */
+    async get(connectionId) {
+        const url = this.parser.url('/backend/connection/$connection_id<[0-9]+|^~>', {
+            'connection_id': connectionId,
+        });
+        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<FormContainer>}
+     * @throws {ClientException}
+     */
+    async getForm(_class) {
+        const url = this.parser.url('/backend/connection/form', {});
+        let params = {
+            url: url,
+            method: 'GET',
+            params: this.parser.query({
+                'class': _class,
+            }),
+        };
+        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<ConnectionIndex>}
+     * @throws {ClientException}
+     */
+    async getClasses() {
+        const url = this.parser.url('/backend/connection/list', {});
+        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<ConnectionCollection>}
+     * @throws {ClientException}
+     */
+    async create(payload) {
+        const url = this.parser.url('/backend/connection', {});
+        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<ConnectionCollection>}
+     * @throws {ClientException}
+     */
+    async getAll(startIndex, count, search) {
+        const url = this.parser.url('/backend/connection', {});
+        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/CronjobTag.d.ts

@@ -0,0 +1,37 @@
+/**
+ * CronjobTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { Cronjob } from "./Cronjob";
+import { CronjobCollection } from "./CronjobCollection";
+import { CronjobCreate } from "./CronjobCreate";
+import { CronjobUpdate } from "./CronjobUpdate";
+import { Message } from "./Message";
+export declare class CronjobTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    delete(cronjobId: string): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    update(cronjobId: string, payload: CronjobUpdate): Promise<Message>;
+    /**
+     * @returns {Promise<Cronjob>}
+     * @throws {ClientException}
+     */
+    get(cronjobId: string): Promise<Cronjob>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    create(payload: CronjobCreate): Promise<Message>;
+    /**
+     * @returns {Promise<CronjobCollection>}
+     * @throws {ClientException}
+     */
+    getAll(startIndex?: number, count?: number, search?: string): Promise<CronjobCollection>;
+}

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

@@ -0,0 +1,146 @@
+/**
+ * CronjobTag 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 CronjobTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async delete(cronjobId) {
+        const url = this.parser.url('/backend/cronjob/$cronjob_id<[0-9]+|^~>', {
+            'cronjob_id': cronjobId,
+        });
+        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(cronjobId, payload) {
+        const url = this.parser.url('/backend/cronjob/$cronjob_id<[0-9]+|^~>', {
+            'cronjob_id': cronjobId,
+        });
+        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<Cronjob>}
+     * @throws {ClientException}
+     */
+    async get(cronjobId) {
+        const url = this.parser.url('/backend/cronjob/$cronjob_id<[0-9]+|^~>', {
+            'cronjob_id': cronjobId,
+        });
+        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/cronjob', {});
+        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<CronjobCollection>}
+     * @throws {ClientException}
+     */
+    async getAll(startIndex, count, search) {
+        const url = this.parser.url('/backend/cronjob', {});
+        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/Dashboard.d.ts

@@ -8,11 +8,11 @@ import { DashboardRequests } from "./DashboardRequests";
 import { DashboardUsers } from "./DashboardUsers";
 import { DashboardTransactions } from "./DashboardTransactions";
 export interface Dashboard {
-    errorsPerRoute?: StatisticChart;
+    errorsPerOperation?: StatisticChart;
     incomingRequests?: StatisticChart;
     incomingTransactions?: StatisticChart;
-    mostUsedRoutes?: StatisticChart;
-    timePerRoute?: StatisticChart;
+    mostUsedOperations?: StatisticChart;
+    timePerOperation?: StatisticChart;
     latestApps?: DashboardApps;
     latestRequests?: DashboardRequests;
     latestUsers?: DashboardUsers;

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

@@ -0,0 +1,13 @@
+/**
+ * DashboardTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { Dashboard } from "./Dashboard";
+export declare class DashboardTag extends TagAbstract {
+    /**
+     * @returns {Promise<Dashboard>}
+     * @throws {ClientException}
+     */
+    getAll(): Promise<Dashboard>;
+}