fusio-sdk 3.0.3 → 3.0.5

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

@@ -0,0 +1,93 @@
+/**
+ * TrashTag 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 TrashTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async restore(type, payload) {
+        const url = this.parser.url('/backend/trash/:type', {
+            'type': type,
+        });
+        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<TrashDataCollection>}
+     * @throws {ClientException}
+     */
+    async getAllByType(type, startIndex, count, search) {
+        const url = this.parser.url('/backend/trash/:type', {
+            'type': type,
+        });
+        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));
+        }
+    }
+    /**
+     * @returns {Promise<TrashTypes>}
+     * @throws {ClientException}
+     */
+    async getTypes() {
+        const url = this.parser.url('/backend/trash', {});
+        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/UserTag.d.ts

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

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

@@ -0,0 +1,146 @@
+/**
+ * UserTag 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 UserTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async delete(userId) {
+        const url = this.parser.url('/backend/user/$user_id<[0-9]+>', {
+            'user_id': userId,
+        });
+        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(userId, payload) {
+        const url = this.parser.url('/backend/user/$user_id<[0-9]+>', {
+            'user_id': userId,
+        });
+        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<User>}
+     * @throws {ClientException}
+     */
+    async get(userId) {
+        const url = this.parser.url('/backend/user/$user_id<[0-9]+>', {
+            'user_id': userId,
+        });
+        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/user', {});
+        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<UserCollection>}
+     * @throws {ClientException}
+     */
+    async getAll(startIndex, count, search) {
+        const url = this.parser.url('/backend/user', {});
+        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/consumer/AccountTag.d.ts

@@ -0,0 +1,81 @@
+/**
+ * AccountTag automatically generated by SDKgen please do not edit this file manually
+ * {@link https://sdkgen.app}
+ */
+import { TagAbstract } from "sdkgen-client";
+import { AccountChangePassword } from "./AccountChangePassword";
+import { AuthorizeMeta } from "./AuthorizeMeta";
+import { AuthorizeRequest } from "./AuthorizeRequest";
+import { AuthorizeResponse } from "./AuthorizeResponse";
+import { Message } from "./Message";
+import { UserAccount } from "./UserAccount";
+import { UserActivate } from "./UserActivate";
+import { UserEmail } from "./UserEmail";
+import { UserJWT } from "./UserJWT";
+import { UserLogin } from "./UserLogin";
+import { UserPasswordReset } from "./UserPasswordReset";
+import { UserProvider } from "./UserProvider";
+import { UserRefresh } from "./UserRefresh";
+import { UserRegister } from "./UserRegister";
+export declare class AccountTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    executePasswordReset(payload: UserPasswordReset): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    requestPasswordReset(payload: UserEmail): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    register(payload: UserRegister): Promise<Message>;
+    /**
+     * @returns {Promise<UserJWT>}
+     * @throws {ClientException}
+     */
+    provider(provider: string, payload: UserProvider): Promise<UserJWT>;
+    /**
+     * @returns {Promise<UserJWT>}
+     * @throws {ClientException}
+     */
+    refresh(payload: UserRefresh): Promise<UserJWT>;
+    /**
+     * @returns {Promise<UserJWT>}
+     * @throws {ClientException}
+     */
+    login(payload: UserLogin): Promise<UserJWT>;
+    /**
+     * @returns {Promise<AuthorizeResponse>}
+     * @throws {ClientException}
+     */
+    authorize(payload: AuthorizeRequest): Promise<AuthorizeResponse>;
+    /**
+     * @returns {Promise<AuthorizeMeta>}
+     * @throws {ClientException}
+     */
+    getApp(): Promise<AuthorizeMeta>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    activate(payload: UserActivate): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    changePassword(payload: AccountChangePassword): Promise<Message>;
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    update(payload: UserAccount): Promise<Message>;
+    /**
+     * @returns {Promise<UserAccount>}
+     * @throws {ClientException}
+     */
+    get(): Promise<UserAccount>;
+}

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

@@ -0,0 +1,321 @@
+/**
+ * AccountTag 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 AccountTag extends TagAbstract {
+    /**
+     * @returns {Promise<Message>}
+     * @throws {ClientException}
+     */
+    async executePasswordReset(payload) {
+        const url = this.parser.url('/consumer/password_reset', {});
+        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 requestPasswordReset(payload) {
+        const url = this.parser.url('/consumer/password_reset', {});
+        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<Message>}
+     * @throws {ClientException}
+     */
+    async register(payload) {
+        const url = this.parser.url('/consumer/register', {});
+        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<UserJWT>}
+     * @throws {ClientException}
+     */
+    async provider(provider, payload) {
+        const url = this.parser.url('/consumer/provider/: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<UserJWT>}
+     * @throws {ClientException}
+     */
+    async refresh(payload) {
+        const url = this.parser.url('/consumer/login', {});
+        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<UserJWT>}
+     * @throws {ClientException}
+     */
+    async login(payload) {
+        const url = this.parser.url('/consumer/login', {});
+        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<AuthorizeResponse>}
+     * @throws {ClientException}
+     */
+    async authorize(payload) {
+        const url = this.parser.url('/consumer/authorize', {});
+        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<AuthorizeMeta>}
+     * @throws {ClientException}
+     */
+    async getApp() {
+        const url = this.parser.url('/consumer/authorize', {});
+        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 activate(payload) {
+        const url = this.parser.url('/consumer/activate', {});
+        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<Message>}
+     * @throws {ClientException}
+     */
+    async changePassword(payload) {
+        const url = this.parser.url('/consumer/account/change_password', {});
+        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 update(payload) {
+        const url = this.parser.url('/consumer/account', {});
+        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<UserAccount>}
+     * @throws {ClientException}
+     */
+    async get() {
+        const url = this.parser.url('/consumer/account', {});
+        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));
+        }
+    }
+}