@fenixalliance/abs-api-client 1.0.2 → 2.0.0

package/clients/holderService/services/HolderService.ts

@@ -1,236 +1,356 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { AddressDtoListEnvelope } from '../models/AddressDtoListEnvelope';
-import type { CartDtoEnvelope } from '../models/CartDtoEnvelope';
-import type { FollowRecordDto } from '../models/FollowRecordDto';
-import type { InvoiceDtoListEnvelope } from '../models/InvoiceDtoListEnvelope';
-import type { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
-import type { OrderDtoListEnvelope } from '../models/OrderDtoListEnvelope';
-import type { PaymentDtoListEnvelope } from '../models/PaymentDtoListEnvelope';
-import type { PlatformUserDtoEnvelope } from '../models/PlatformUserDtoEnvelope';
-import type { SocialProfileDtoEnvelope } from '../models/SocialProfileDtoEnvelope';
-import type { TenantDtoListEnvelope } from '../models/TenantDtoListEnvelope';
-import type { TenantEnrollmentDtoListEnvelope } from '../models/TenantEnrollmentDtoListEnvelope';
-import type { WalletDtoEnvelope } from '../models/WalletDtoEnvelope';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class HolderService {
-    /**
-     * Get the current user profile
-     * @returns PlatformUserDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2Me(): CancelablePromise<PlatformUserDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @param pageSize
-     * @param pageIndex
-     * @returns FollowRecordDto Success
-     * @throws ApiError
-     */
-    public static getApiV2MeFollows(
-        pageSize: number = 25,
-        pageIndex?: number,
-    ): CancelablePromise<Array<FollowRecordDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Follows',
-            query: {
-                'pageSize': pageSize,
-                'pageIndex': pageIndex,
-            },
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @param pageSize
-     * @param pageIndex
-     * @returns FollowRecordDto Success
-     * @throws ApiError
-     */
-    public static getApiV2MeFollowers(
-        pageSize: number = 25,
-        pageIndex?: number,
-    ): CancelablePromise<Array<FollowRecordDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Followers',
-            query: {
-                'pageSize': pageSize,
-                'pageIndex': pageIndex,
-            },
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns TenantDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeBusinesses(): CancelablePromise<TenantDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Businesses',
-            errors: {
-                401: `Unauthorized`,
-                403: `Forbidden`,
-            },
-        });
-    }
-    /**
-     * @returns TenantEnrollmentDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeEnrollments(): CancelablePromise<TenantEnrollmentDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Enrollments',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns SocialProfileDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeSocialProfile(): CancelablePromise<SocialProfileDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/SocialProfile',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns CartDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeCart(): CancelablePromise<CartDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Cart',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns WalletDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeWallet(): CancelablePromise<WalletDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Wallet',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns NotificationDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeNotifications(): CancelablePromise<NotificationDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Notifications',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns void
-     * @throws ApiError
-     */
-    public static getApiV2MeSettings(): CancelablePromise<void> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Settings',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2MeLibrary(): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Library',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns AddressDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeAddresses(): CancelablePromise<AddressDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Addresses',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns OrderDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeOrders(): CancelablePromise<OrderDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Orders',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns InvoiceDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MeInvoices(): CancelablePromise<InvoiceDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Invoices',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns PaymentDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2MePayments(): CancelablePromise<PaymentDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Payments',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AddressDtoListEnvelope } from '../models/AddressDtoListEnvelope';
+import type { CartDtoEnvelope } from '../models/CartDtoEnvelope';
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { EmptyEnvelopeEnvelope } from '../models/EmptyEnvelopeEnvelope';
+import type { EnrollmentId } from '../models/EnrollmentId';
+import type { ExtendedPlatformUserDtoEnvelope } from '../models/ExtendedPlatformUserDtoEnvelope';
+import type { ExtendedTenantDtoListEnvelope } from '../models/ExtendedTenantDtoListEnvelope';
+import type { ExtendedTenantEnrolmentDtoListEnvelope } from '../models/ExtendedTenantEnrolmentDtoListEnvelope';
+import type { FollowRecordDto } from '../models/FollowRecordDto';
+import type { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
+import type { Operation } from '../models/Operation';
+import type { PlatformUserDtoEnvelope } from '../models/PlatformUserDtoEnvelope';
+import type { PlatformUserSettingsDtoEnvelope } from '../models/PlatformUserSettingsDtoEnvelope';
+import type { PlatformUserSettingsUpdateDto } from '../models/PlatformUserSettingsUpdateDto';
+import type { PlatformUserUpdateDto } from '../models/PlatformUserUpdateDto';
+import type { SocialProfileDtoEnvelope } from '../models/SocialProfileDtoEnvelope';
+import type { TenantDtoListEnvelope } from '../models/TenantDtoListEnvelope';
+import type { TenantEnrolmentDtoEnvelope } from '../models/TenantEnrolmentDtoEnvelope';
+import type { TenantEnrolmentDtoListEnvelope } from '../models/TenantEnrolmentDtoListEnvelope';
+import type { TenantInvitationDtoListEnvelope } from '../models/TenantInvitationDtoListEnvelope';
+import type { WalletDtoEnvelope } from '../models/WalletDtoEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class HolderService {
+    /**
+     * @returns PlatformUserDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Me(): CancelablePromise<PlatformUserDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns EmptyEnvelopeEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Me(
+        requestBody?: PlatformUserUpdateDto,
+    ): CancelablePromise<EmptyEnvelopeEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Me',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns EmptyEnvelopeEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Me(
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelopeEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Me',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns ExtendedPlatformUserDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeExtended(): CancelablePromise<ExtendedPlatformUserDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Extended',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns FollowRecordDto OK
+     * @throws ApiError
+     */
+    public static getApiV2MeAvatar(): CancelablePromise<Array<FollowRecordDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Avatar',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param formData
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2MeAvatar(
+        formData?: {
+            avatar?: Blob;
+        },
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Me/Avatar',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param pageSize
+     * @param pageIndex
+     * @returns FollowRecordDto OK
+     * @throws ApiError
+     */
+    public static getApiV2MeFollows(
+        pageSize: number = 25,
+        pageIndex?: number,
+    ): CancelablePromise<Array<FollowRecordDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Follows',
+            query: {
+                'pageSize': pageSize,
+                'pageIndex': pageIndex,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param pageSize
+     * @param pageIndex
+     * @returns FollowRecordDto OK
+     * @throws ApiError
+     */
+    public static getApiV2MeFollowers(
+        pageSize: number = 25,
+        pageIndex?: number,
+    ): CancelablePromise<Array<FollowRecordDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Followers',
+            query: {
+                'pageSize': pageSize,
+                'pageIndex': pageIndex,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns TenantDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeBusinesses(): CancelablePromise<TenantDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Businesses',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @returns ExtendedTenantDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeBusinessesExtended(): CancelablePromise<ExtendedTenantDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Businesses/Extended',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @returns TenantEnrolmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeEnrollments(): CancelablePromise<TenantEnrolmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Enrollments',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns ExtendedTenantEnrolmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeEnrollmentsExtended(): CancelablePromise<ExtendedTenantEnrolmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Enrollments/Extended',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param enrollmentId
+     * @param requestBody
+     * @returns TenantEnrolmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeEnrollments1(
+        enrollmentId: string,
+        requestBody?: EnrollmentId,
+    ): CancelablePromise<TenantEnrolmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Enrollments/{enrollmentId}',
+            path: {
+                'enrollmentId': enrollmentId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns SocialProfileDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeSocialProfile(): CancelablePromise<SocialProfileDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/SocialProfile',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns CartDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeCart(): CancelablePromise<CartDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Cart',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns WalletDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeWallet(): CancelablePromise<WalletDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Wallet',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns NotificationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeNotifications(): CancelablePromise<NotificationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Notifications',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns PlatformUserSettingsDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeSettings(): CancelablePromise<PlatformUserSettingsDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Settings',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns PlatformUserSettingsDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2MeSettings(
+        requestBody?: PlatformUserSettingsUpdateDto,
+    ): CancelablePromise<PlatformUserSettingsDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Me/Settings',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns AddressDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeAddresses(): CancelablePromise<AddressDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Addresses',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeInvitations(): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Invitations',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+}

package/clients/identityService/core/ApiError.ts

@@ -1,4 +1,4 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -22,4 +22,4 @@ export class ApiError extends Error {
         this.body = response.body;
         this.request = request;
     }
-}
+}

package/clients/identityService/core/ApiRequestOptions.ts

@@ -1,4 +1,4 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -14,4 +14,4 @@ export type ApiRequestOptions = {
     readonly mediaType?: string;
     readonly responseHeader?: string;
     readonly errors?: Record<number, string>;
-};
+};

package/clients/identityService/core/ApiResult.ts

@@ -1,4 +1,4 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -8,4 +8,4 @@ export type ApiResult = {
     readonly status: number;
     readonly statusText: string;
     readonly body: any;
-};
+};

package/clients/identityService/core/CancelablePromise.ts

@@ -1,4 +1,4 @@
-/* generated using openapi-typescript-codegen -- do no edit */
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -85,9 +85,9 @@ export class CancelablePromise<T> implements Promise<T> {
         });
     }
 
-     get [Symbol.toStringTag]() {
-            return "Cancellable Promise";
-     }
+    get [Symbol.toStringTag]() {
+        return "Cancellable Promise";
+    }
 
     public then<TResult1 = T, TResult2 = never>(
         onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
@@ -128,4 +128,4 @@ export class CancelablePromise<T> implements Promise<T> {
     public get isCancelled(): boolean {
         return this.#isCancelled;
     }
-}
+}