@fenixalliance/abs-api-client 1.0.1 → 2.0.0

package/clients/holderService/services/HolderService.ts

@@ -1,165 +1,356 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { AccountHolderDtoEnvelope } from '../models/AccountHolderDtoEnvelope';
-import type { BusinessDto } from '../models/BusinessDto';
-import type { BusinessEnrollmentDto } from '../models/BusinessEnrollmentDto';
-import type { FollowRecordDto } from '../models/FollowRecordDto';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class HolderService {
-    /**
-     * @returns AccountHolderDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2Me(): CancelablePromise<AccountHolderDtoEnvelope> {
-        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`,
-            },
-        });
-    }
-    /**
-     * @returns BusinessDto Success
-     * @throws ApiError
-     */
-    public static getApiV2MeBusinesses(): CancelablePromise<Array<BusinessDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Businesses',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns BusinessEnrollmentDto Success
-     * @throws ApiError
-     */
-    public static getApiV2MeEnrollments(): CancelablePromise<Array<BusinessEnrollmentDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Enrollments',
-            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 void
-     * @throws ApiError
-     */
-    public static getApiV2MeAddresses(): CancelablePromise<void> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Addresses',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns void
-     * @throws ApiError
-     */
-    public static getApiV2MeNotifications(): CancelablePromise<void> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Notifications',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns void
-     * @throws ApiError
-     */
-    public static getApiV2MeOrders(): CancelablePromise<void> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Orders',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns void
-     * @throws ApiError
-     */
-    public static getApiV2MeInvoices(): CancelablePromise<void> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Invoices',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @returns void
-     * @throws ApiError
-     */
-    public static getApiV2MePayments(): CancelablePromise<void> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Payments',
-            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`,
-            },
-        });
-    }
-}
+/* 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,25 +1,25 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { ApiRequestOptions } from './ApiRequestOptions';
-import type { ApiResult } from './ApiResult';
-
-export class ApiError extends Error {
-    public readonly url: string;
-    public readonly status: number;
-    public readonly statusText: string;
-    public readonly body: any;
-    public readonly request: ApiRequestOptions;
-
-    constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
-        super(message);
-
-        this.name = 'ApiError';
-        this.url = response.url;
-        this.status = response.status;
-        this.statusText = response.statusText;
-        this.body = response.body;
-        this.request = request;
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+
+export class ApiError extends Error {
+    public readonly url: string;
+    public readonly status: number;
+    public readonly statusText: string;
+    public readonly body: any;
+    public readonly request: ApiRequestOptions;
+
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
+        super(message);
+
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/clients/identityService/core/ApiRequestOptions.ts

@@ -1,17 +1,17 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export type ApiRequestOptions = {
-    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
-    readonly url: string;
-    readonly path?: Record<string, any>;
-    readonly cookies?: Record<string, any>;
-    readonly headers?: Record<string, any>;
-    readonly query?: Record<string, any>;
-    readonly formData?: Record<string, any>;
-    readonly body?: any;
-    readonly mediaType?: string;
-    readonly responseHeader?: string;
-    readonly errors?: Record<number, string>;
-};
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/clients/identityService/core/ApiResult.ts

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