@drttix/drt-sdk 0.9.2 → 0.9.4

package/src/generated/portal/services/AppService.ts

@@ -1,33 +1,33 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { BuyerResponseDto } from '../models/BuyerResponseDto';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class AppService {
-    /**
-     * Fetch the buyer details for the order
-     * Fetch the buyer details for the order
-     * @param xStudioId The ID of the studio
-     * @param orderId The ID of the order
-     * @returns BuyerResponseDto Buyer details for the order fetched successfully
-     * @throws ApiError
-     */
-    public static getBuyer(
-        xStudioId: string,
-        orderId: string,
-    ): CancelablePromise<BuyerResponseDto> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/{orderId}/buyer-details',
-            path: {
-                'orderId': orderId,
-            },
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BuyerResponseDto } from '../models/BuyerResponseDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class AppService {
+    /**
+     * Fetch the buyer details for the order
+     * Fetch the buyer details for the order
+     * @param xStudioId The ID of the studio
+     * @param orderId The ID of the order
+     * @returns BuyerResponseDto Buyer details for the order fetched successfully
+     * @throws ApiError
+     */
+    public static getBuyer(
+        xStudioId: string,
+        orderId: string,
+    ): CancelablePromise<BuyerResponseDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/{orderId}/buyer-details',
+            path: {
+                'orderId': orderId,
+            },
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+}

package/src/generated/portal/services/AuthService.ts

@@ -1,164 +1,164 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { ChangePasswordRequestDto } from '../models/ChangePasswordRequestDto';
-import type { ForgotPasswordRequestDto } from '../models/ForgotPasswordRequestDto';
-import type { HashLoginResponseDto } from '../models/HashLoginResponseDto';
-import type { LoginRequestDto } from '../models/LoginRequestDto';
-import type { MappedPortalObjectSimple } from '../models/MappedPortalObjectSimple';
-import type { OTPResponseDto } from '../models/OTPResponseDto';
-import type { SuccessResponse } from '../models/SuccessResponse';
-import type { VerifyOtpRequestDto } from '../models/VerifyOtpRequestDto';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class AuthService {
-    /**
-     * Forgot password
-     * Send forgot password email
-     * @param xStudioId The ID of the studio
-     * @param requestBody Credential needs to be verified
-     * @returns SuccessResponse Forgot password email sent
-     * @throws ApiError
-     */
-    public static sendForgotPassword(
-        xStudioId: string,
-        requestBody: ForgotPasswordRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/auth/forgot-password',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Verify OTP
-     * Verify the OTP sent to the user
-     * @param xStudioId The ID of the studio
-     * @param requestBody Credential needs to be verified
-     * @returns OTPResponseDto OTP verification successful
-     * @throws ApiError
-     */
-    public static verifyOtp(
-        xStudioId: string,
-        requestBody: VerifyOtpRequestDto,
-    ): CancelablePromise<OTPResponseDto> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/auth/verify-otp',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Login verification
-     * Login verification with credentials
-     * @param xStudioId
-     * @param requestBody Credential needs to be verified
-     * @returns MappedPortalObjectSimple Login successful and permissions retrieved
-     * @throws ApiError
-     */
-    public static login(
-        xStudioId: string,
-        requestBody: LoginRequestDto,
-    ): CancelablePromise<Array<MappedPortalObjectSimple>> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/auth/login',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Logging out the user
-     * Logging out the user
-     * @param xStudioId
-     * @returns SuccessResponse Logout successful
-     * @throws ApiError
-     */
-    public static logout(
-        xStudioId: string,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/auth/logout',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Change Password
-     * Change the user password
-     * @param xStudioId The ID of the studio
-     * @param requestBody Credential needs to be verified
-     * @returns SuccessResponse Password changed successful
-     * @throws ApiError
-     */
-    public static changePassword(
-        xStudioId: string,
-        requestBody: ChangePasswordRequestDto,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/auth/change-password',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * Hash-based login
-     * Passwordless login using a secure hash
-     * @param xStudioId The ID of the studio
-     * @param pw Authentication hash
-     * @param userId User ID
-     * @param report Report to redirect to after login
-     * @returns HashLoginResponseDto Hash login successful
-     * @throws ApiError
-     */
-    public static hashLogin(
-        xStudioId: string,
-        pw: string,
-        userId: number,
-        report?: string,
-    ): CancelablePromise<HashLoginResponseDto> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/auth/hash-login',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            query: {
-                'pw': pw,
-                'user_id': userId,
-                'report': report,
-            },
-        });
-    }
-    /**
-     * Refresh Portal Routes Cache
-     * Refresh the cached portal routes
-     * @returns SuccessResponse Portal routes cache refreshed successfully
-     * @throws ApiError
-     */
-    public static refreshPortalRoutesCache(): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/auth/refresh-portal-routes-cache',
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ChangePasswordRequestDto } from '../models/ChangePasswordRequestDto';
+import type { ForgotPasswordRequestDto } from '../models/ForgotPasswordRequestDto';
+import type { HashLoginResponseDto } from '../models/HashLoginResponseDto';
+import type { LoginRequestDto } from '../models/LoginRequestDto';
+import type { MappedPortalObjectSimple } from '../models/MappedPortalObjectSimple';
+import type { OTPResponseDto } from '../models/OTPResponseDto';
+import type { SuccessResponse } from '../models/SuccessResponse';
+import type { VerifyOtpRequestDto } from '../models/VerifyOtpRequestDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class AuthService {
+    /**
+     * Forgot password
+     * Send forgot password email
+     * @param xStudioId The ID of the studio
+     * @param requestBody Credential needs to be verified
+     * @returns SuccessResponse Forgot password email sent
+     * @throws ApiError
+     */
+    public static sendForgotPassword(
+        xStudioId: string,
+        requestBody: ForgotPasswordRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/forgot-password',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Verify OTP
+     * Verify the OTP sent to the user
+     * @param xStudioId The ID of the studio
+     * @param requestBody Credential needs to be verified
+     * @returns OTPResponseDto OTP verification successful
+     * @throws ApiError
+     */
+    public static verifyOtp(
+        xStudioId: string,
+        requestBody: VerifyOtpRequestDto,
+    ): CancelablePromise<OTPResponseDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/verify-otp',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Login verification
+     * Login verification with credentials
+     * @param xStudioId
+     * @param requestBody Credential needs to be verified
+     * @returns MappedPortalObjectSimple Login successful and permissions retrieved
+     * @throws ApiError
+     */
+    public static login(
+        xStudioId: string,
+        requestBody: LoginRequestDto,
+    ): CancelablePromise<Array<MappedPortalObjectSimple>> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/login',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Logging out the user
+     * Logging out the user
+     * @param xStudioId
+     * @returns SuccessResponse Logout successful
+     * @throws ApiError
+     */
+    public static logout(
+        xStudioId: string,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/logout',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Change Password
+     * Change the user password
+     * @param xStudioId The ID of the studio
+     * @param requestBody Credential needs to be verified
+     * @returns SuccessResponse Password changed successful
+     * @throws ApiError
+     */
+    public static changePassword(
+        xStudioId: string,
+        requestBody: ChangePasswordRequestDto,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/change-password',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Hash-based login
+     * Passwordless login using a secure hash
+     * @param xStudioId The ID of the studio
+     * @param pw Authentication hash
+     * @param userId User ID
+     * @param report Report to redirect to after login
+     * @returns HashLoginResponseDto Hash login successful
+     * @throws ApiError
+     */
+    public static hashLogin(
+        xStudioId: string,
+        pw: string,
+        userId: number,
+        report?: string,
+    ): CancelablePromise<HashLoginResponseDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/auth/hash-login',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            query: {
+                'pw': pw,
+                'user_id': userId,
+                'report': report,
+            },
+        });
+    }
+    /**
+     * Refresh Portal Routes Cache
+     * Refresh the cached portal routes
+     * @returns SuccessResponse Portal routes cache refreshed successfully
+     * @throws ApiError
+     */
+    public static refreshPortalRoutesCache(): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/refresh-portal-routes-cache',
+        });
+    }
+}

package/src/generated/portal/services/BookmarkService.ts

@@ -1,99 +1,99 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { BookmarkResponseDto } from '../models/BookmarkResponseDto';
-import type { CheckBookmarkResponseDto } from '../models/CheckBookmarkResponseDto';
-import type { SuccessResponse } from '../models/SuccessResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class BookmarkService {
-    /**
-     * Fetch the bookmarks
-     * Fetch the bookmarks
-     * @param xStudioId The ID of the studio
-     * @returns BookmarkResponseDto Bookmarks fetched successfully
-     * @throws ApiError
-     */
-    public static getBookmarks(
-        xStudioId: string,
-    ): CancelablePromise<Array<BookmarkResponseDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/bookmark',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-        });
-    }
-    /**
-     * Check if a bookmark exists
-     * Check if a bookmark exists
-     * @param xStudioId The ID of the studio
-     * @param path Value of the bookmark path
-     * @returns CheckBookmarkResponseDto Bookmark exists check successful
-     * @throws ApiError
-     */
-    public static checkBookmarkExists(
-        xStudioId: string,
-        path: string,
-    ): CancelablePromise<CheckBookmarkResponseDto> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/bookmark/check',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            query: {
-                'path': path,
-            },
-        });
-    }
-    /**
-     * Create or update a bookmark
-     * Create or update a bookmark
-     * @param xStudioId The ID of the studio
-     * @param path Value of the bookmark path
-     * @returns SuccessResponse Bookmarks created or updated successfully
-     * @throws ApiError
-     */
-    public static createOrUpdateBookmark(
-        xStudioId: string,
-        path: string,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/bookmark/create-update',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            query: {
-                'path': path,
-            },
-        });
-    }
-    /**
-     * Clear a bookmark
-     * Clear a bookmark
-     * @param xStudioId The ID of the studio
-     * @param path Value of the bookmark path
-     * @returns SuccessResponse Bookmarks cleared successfully
-     * @throws ApiError
-     */
-    public static clearBookmark(
-        xStudioId: string,
-        path: string,
-    ): CancelablePromise<SuccessResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/bookmark/clear',
-            headers: {
-                'x-studio-id': xStudioId,
-            },
-            query: {
-                'path': path,
-            },
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BookmarkResponseDto } from '../models/BookmarkResponseDto';
+import type { CheckBookmarkResponseDto } from '../models/CheckBookmarkResponseDto';
+import type { SuccessResponse } from '../models/SuccessResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class BookmarkService {
+    /**
+     * Fetch the bookmarks
+     * Fetch the bookmarks
+     * @param xStudioId The ID of the studio
+     * @returns BookmarkResponseDto Bookmarks fetched successfully
+     * @throws ApiError
+     */
+    public static getBookmarks(
+        xStudioId: string,
+    ): CancelablePromise<Array<BookmarkResponseDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/bookmark',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+        });
+    }
+    /**
+     * Check if a bookmark exists
+     * Check if a bookmark exists
+     * @param xStudioId The ID of the studio
+     * @param path Value of the bookmark path
+     * @returns CheckBookmarkResponseDto Bookmark exists check successful
+     * @throws ApiError
+     */
+    public static checkBookmarkExists(
+        xStudioId: string,
+        path: string,
+    ): CancelablePromise<CheckBookmarkResponseDto> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/bookmark/check',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            query: {
+                'path': path,
+            },
+        });
+    }
+    /**
+     * Create or update a bookmark
+     * Create or update a bookmark
+     * @param xStudioId The ID of the studio
+     * @param path Value of the bookmark path
+     * @returns SuccessResponse Bookmarks created or updated successfully
+     * @throws ApiError
+     */
+    public static createOrUpdateBookmark(
+        xStudioId: string,
+        path: string,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/bookmark/create-update',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            query: {
+                'path': path,
+            },
+        });
+    }
+    /**
+     * Clear a bookmark
+     * Clear a bookmark
+     * @param xStudioId The ID of the studio
+     * @param path Value of the bookmark path
+     * @returns SuccessResponse Bookmarks cleared successfully
+     * @throws ApiError
+     */
+    public static clearBookmark(
+        xStudioId: string,
+        path: string,
+    ): CancelablePromise<SuccessResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/bookmark/clear',
+            headers: {
+                'x-studio-id': xStudioId,
+            },
+            query: {
+                'path': path,
+            },
+        });
+    }
+}