@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/holderService/services/HolderService.ts

@@ -4,47 +4,176 @@
 /* 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 { InvoiceDtoListEnvelope } from '../models/InvoiceDtoListEnvelope';
 import type { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
-import type { OrderDtoListEnvelope } from '../models/OrderDtoListEnvelope';
-import type { PaymentDtoListEnvelope } from '../models/PaymentDtoListEnvelope';
+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 { TenantEnrollmentDtoListEnvelope } from '../models/TenantEnrollmentDtoListEnvelope';
+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 {
     /**
-     * Get the current user profile
-     * @returns PlatformUserDtoEnvelope Success
+     * @param xApiVersion
+     * @returns PlatformUserDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2Me(): CancelablePromise<PlatformUserDtoEnvelope> {
+    public static getApiV2Me(
+        xApiVersion?: string,
+    ): CancelablePromise<PlatformUserDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Me',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelopeEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Me(
+        xApiVersion?: string,
+        requestBody?: PlatformUserUpdateDto,
+    ): CancelablePromise<EmptyEnvelopeEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Me',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelopeEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Me(
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelopeEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Me',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns ExtendedPlatformUserDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2MeExtended(
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedPlatformUserDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Extended',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns FollowRecordDto OK
+     * @throws ApiError
+     */
+    public static getApiV2MeAvatar(
+        xApiVersion?: string,
+    ): CancelablePromise<Array<FollowRecordDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Avatar',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @param formData
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2MeAvatar(
+        xApiVersion?: string,
+        formData?: {
+            avatar?: Blob;
+        },
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Me/Avatar',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
             errors: {
                 401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
      * @param pageSize
      * @param pageIndex
-     * @returns FollowRecordDto Success
+     * @param xApiVersion
+     * @returns FollowRecordDto OK
      * @throws ApiError
      */
     public static getApiV2MeFollows(
         pageSize: number = 25,
         pageIndex?: number,
+        xApiVersion?: string,
     ): CancelablePromise<Array<FollowRecordDto>> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Me/Follows',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'pageSize': pageSize,
                 'pageIndex': pageIndex,
@@ -57,16 +186,21 @@ export class HolderService {
     /**
      * @param pageSize
      * @param pageIndex
-     * @returns FollowRecordDto Success
+     * @param xApiVersion
+     * @returns FollowRecordDto OK
      * @throws ApiError
      */
     public static getApiV2MeFollowers(
         pageSize: number = 25,
         pageIndex?: number,
+        xApiVersion?: string,
     ): CancelablePromise<Array<FollowRecordDto>> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Me/Followers',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'pageSize': pageSize,
                 'pageIndex': pageIndex,
@@ -77,13 +211,19 @@ export class HolderService {
         });
     }
     /**
-     * @returns TenantDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns TenantDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeBusinesses(): CancelablePromise<TenantDtoListEnvelope> {
+    public static getApiV2MeBusinesses(
+        xApiVersion?: string,
+    ): CancelablePromise<TenantDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Me/Businesses',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -91,143 +231,242 @@ export class HolderService {
         });
     }
     /**
-     * @returns TenantEnrollmentDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns ExtendedTenantDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeEnrollments(): CancelablePromise<TenantEnrollmentDtoListEnvelope> {
+    public static getApiV2MeBusinessesExtended(
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedTenantDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Enrollments',
+            url: '/api/v2/Me/Businesses/Extended',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @returns SocialProfileDtoEnvelope Success
+     * @param xApiVersion
+     * @returns TenantEnrolmentDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeSocialProfile(): CancelablePromise<SocialProfileDtoEnvelope> {
+    public static getApiV2MeEnrollments(
+        xApiVersion?: string,
+    ): CancelablePromise<TenantEnrolmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/SocialProfile',
+            url: '/api/v2/Me/Enrollments',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns CartDtoEnvelope Success
+     * @param xApiVersion
+     * @returns ExtendedTenantEnrolmentDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeCart(): CancelablePromise<CartDtoEnvelope> {
+    public static getApiV2MeEnrollmentsExtended(
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedTenantEnrolmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Cart',
+            url: '/api/v2/Me/Enrollments/Extended',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns WalletDtoEnvelope Success
+     * @param enrollmentId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantEnrolmentDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeWallet(): CancelablePromise<WalletDtoEnvelope> {
+    public static getApiV2MeEnrollments1(
+        enrollmentId: string,
+        xApiVersion?: string,
+        requestBody?: EnrollmentId,
+    ): CancelablePromise<TenantEnrolmentDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Wallet',
+            url: '/api/v2/Me/Enrollments/{enrollmentId}',
+            path: {
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns NotificationDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns SocialProfileDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeNotifications(): CancelablePromise<NotificationDtoListEnvelope> {
+    public static getApiV2MeSocialProfile(
+        xApiVersion?: string,
+    ): CancelablePromise<SocialProfileDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Notifications',
+            url: '/api/v2/Me/SocialProfile',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns void
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeSettings(): CancelablePromise<void> {
+    public static getApiV2MeCart(
+        xApiVersion?: string,
+    ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Settings',
+            url: '/api/v2/Me/Cart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns any Success
+     * @param xApiVersion
+     * @returns WalletDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeLibrary(): CancelablePromise<any> {
+    public static getApiV2MeWallet(
+        xApiVersion?: string,
+    ): CancelablePromise<WalletDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Library',
+            url: '/api/v2/Me/Wallet',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns AddressDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns NotificationDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeAddresses(): CancelablePromise<AddressDtoListEnvelope> {
+    public static getApiV2MeNotifications(
+        xApiVersion?: string,
+    ): CancelablePromise<NotificationDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Addresses',
+            url: '/api/v2/Me/Notifications',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns OrderDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns PlatformUserSettingsDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeOrders(): CancelablePromise<OrderDtoListEnvelope> {
+    public static getApiV2MeSettings(
+        xApiVersion?: string,
+    ): CancelablePromise<PlatformUserSettingsDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Orders',
+            url: '/api/v2/Me/Settings',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @param requestBody
+     * @returns PlatformUserSettingsDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2MeSettings(
+        xApiVersion?: string,
+        requestBody?: PlatformUserSettingsUpdateDto,
+    ): CancelablePromise<PlatformUserSettingsDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Me/Settings',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns InvoiceDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns AddressDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MeInvoices(): CancelablePromise<InvoiceDtoListEnvelope> {
+    public static getApiV2MeAddresses(
+        xApiVersion?: string,
+    ): CancelablePromise<AddressDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Invoices',
+            url: '/api/v2/Me/Addresses',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * @returns PaymentDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns TenantInvitationDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2MePayments(): CancelablePromise<PaymentDtoListEnvelope> {
+    public static getApiV2MeInvitations(
+        xApiVersion?: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Payments',
+            url: '/api/v2/Me/Invitations',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
             },

package/clients/identityService/index.ts

@@ -7,7 +7,7 @@ export { CancelablePromise, CancelError } from './core/CancelablePromise';
 export { OpenAPI } from './core/OpenAPI';
 export type { OpenAPIConfig } from './core/OpenAPI';
 
-export type { AccountHolderCreateDto } from './models/AccountHolderCreateDto';
+export { AccountHolderCreateDto } from './models/AccountHolderCreateDto';
 export type { AccountHolderCreateDtoEnvelope } from './models/AccountHolderCreateDtoEnvelope';
 export type { Actor } from './models/Actor';
 export type { ApiResponse } from './models/ApiResponse';

package/clients/identityService/models/AccountHolderCreateDto.ts

@@ -11,25 +11,30 @@ export type AccountHolderCreateDto = {
     lastName?: string | null;
     publicName?: string | null;
     idProvider?: string | null;
-    languageID?: string | null;
-    timezoneID?: string | null;
-    gender?: string | null;
-    cityID?: string | null;
-    stateID?: string | null;
+    gender?: AccountHolderCreateDto.gender;
     email?: string | null;
     about?: string | null;
+    status?: string | null;
     jobTitle?: string | null;
-    coverURL?: string | null;
-    avatarURL?: string | null;
-    gitHubURL?: string | null;
-    websiteURL?: string | null;
+    gitHubUrl?: string | null;
+    websiteUrl?: string | null;
     twitterUrl?: string | null;
-    facebookURL?: string | null;
-    youTubeURL?: string | null;
-    linkedInURL?: string | null;
+    facebookUrl?: string | null;
+    youTubeUrl?: string | null;
+    linkedInUrl?: string | null;
     instagramUrl?: string | null;
-    countryID?: string | null;
-    countryName?: string | null;
-    currencyID?: string | null;
+    timezoneId?: string | null;
+    languageId?: string | null;
+    currencyId?: string | null;
+    countryId?: string | null;
+    stateId?: string | null;
+    cityId?: string | null;
 };
+export namespace AccountHolderCreateDto {
+    export enum gender {
+        '_0' = 0,
+        '_1' = 1,
+        '_2' = 2,
+    }
+}
 

package/clients/identityService/models/AccountHolderCreateDtoEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { AccountHolderCreateDto } from './AccountHolderCreateDto';
 export type AccountHolderCreateDtoEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: AccountHolderCreateDto;
 };
 

package/clients/identityService/models/ApiResponseEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { ApiResponse } from './ApiResponse';
 export type ApiResponseEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: ApiResponse;
 };
 

package/clients/identityService/models/ErrorEnvelope.ts

@@ -3,10 +3,10 @@
 /* tslint:disable */
 /* eslint-disable */
 export type ErrorEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
 };
 

package/clients/identityService/models/JsonWebKeySetEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { JsonWebKeySet } from './JsonWebKeySet';
 export type JsonWebKeySetEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: JsonWebKeySet;
 };
 

package/clients/identityService/models/JsonWebTokenEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { JsonWebToken } from './JsonWebToken';
 export type JsonWebTokenEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: JsonWebToken;
 };
 

package/clients/identityService/models/OpenIdConfigurationEnvelope.ts

@@ -4,11 +4,11 @@
 /* eslint-disable */
 import type { OpenIdConfiguration } from './OpenIdConfiguration';
 export type OpenIdConfigurationEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: OpenIdConfiguration;
 };