@fenixalliance/abs-api-client 1.0.8 → 1.0.10

package/clients/holderService/services/UserService.ts

@@ -0,0 +1,421 @@
+/* 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 { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { ExtendedUserDtoEnvelope } from '../models/ExtendedUserDtoEnvelope';
+import type { FollowRecordDtoListEnvelope } from '../models/FollowRecordDtoListEnvelope';
+import type { Int32Envelope } from '../models/Int32Envelope';
+import type { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
+import type { Operation } from '../models/Operation';
+import type { SocialProfileDtoEnvelope } from '../models/SocialProfileDtoEnvelope';
+import type { UserDtoEnvelope } from '../models/UserDtoEnvelope';
+import type { UserSettingsDtoEnvelope } from '../models/UserSettingsDtoEnvelope';
+import type { UserSettingsUpdateDto } from '../models/UserSettingsUpdateDto';
+import type { UserUpdateDto } from '../models/UserUpdateDto';
+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 UserService {
+    /**
+     * Gets the current user
+     * Get the currently acting user.
+     * @param xApiVersion
+     * @returns UserDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<UserDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Update the current user's profile
+     * Update the current user's profile
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static updateCurrentUserAsync(
+        xApiVersion?: string,
+        requestBody?: UserUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Me',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Partially update the current user's profile
+     * Partially update the current user's profile
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchCurrentUserAsync(
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Me',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the current user's extended profile
+     * Get the current user's extended profile
+     * @param xApiVersion
+     * @returns ExtendedUserDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getExtendedCurrentUserAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedUserDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Extended',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the current user's avatar
+     * Get the current user's avatar
+     * @param xApiVersion
+     * @returns binary OK
+     * @throws ApiError
+     */
+    public static getCurrentUserAvatarAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<Blob> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Avatar',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * Update the current user's avatar
+     * Update the current user's avatar
+     * @param xApiVersion
+     * @param formData
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static updateAvatarAsync(
+        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`,
+            },
+        });
+    }
+    /**
+     * Get the social profiles that the current user follows
+     * Get the social profiles that the current user follows
+     * @param xApiVersion
+     * @returns FollowRecordDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserFollowsAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<FollowRecordDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Follows',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Count the social profiles that the current user follows
+     * Count the social profiles that the current user follows
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static countCurrentUserFollowsAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Follows/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the social profiles that follow the current user
+     * Get the social profiles that follow the current user
+     * @param xApiVersion
+     * @returns FollowRecordDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserFollowersAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<FollowRecordDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Followers',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Count the social profiles that follow the current user
+     * Count the social profiles that follow the current user
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static countCurrentUserFollowersAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Followers/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the current user's social profile
+     * Get the current user's social profile
+     * @param xApiVersion
+     * @returns SocialProfileDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserSocialProfileAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<SocialProfileDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/SocialProfile',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the current user's cart
+     * Get the current user's cart
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserCartAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<CartDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Cart',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the current user's billing profile
+     * Get the current user's billing profile
+     * @param xApiVersion
+     * @returns WalletDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserWalletAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<WalletDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Wallet',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the list of notifications for the current user
+     * Get the list of notifications for the current user
+     * @param xApiVersion
+     * @returns NotificationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserNotificationsAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<NotificationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Notifications',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Count the notifications for the current user
+     * Count the notifications for the current user
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static countCurrentUserNotificationsAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Notifications/Count',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the settings for the current user
+     * Get the settings for the current user
+     * @param xApiVersion
+     * @returns UserSettingsDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserSettingsAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<UserSettingsDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Settings',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Update the settings for the current user
+     * Update the settings for the current user
+     * @param xApiVersion
+     * @param requestBody
+     * @returns UserSettingsDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static updateCurrentUserSettingsAsync(
+        xApiVersion?: string,
+        requestBody?: UserSettingsUpdateDto,
+    ): CancelablePromise<UserSettingsDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Me/Settings',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * Get the list of addresses for the current user
+     * Get the list of addresses for the current user
+     * @param xApiVersion
+     * @returns AddressDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getCurrentUserAddressesAsync(
+        xApiVersion?: string,
+    ): CancelablePromise<AddressDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Me/Addresses',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+}

package/clients/storageService/core/ApiError.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    url;
+    status;
+    statusText;
+    body;
+    request;
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}
+exports.ApiError = ApiError;

package/clients/storageService/core/ApiError.ts

@@ -0,0 +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;
+    }
+}

package/clients/storageService/core/ApiRequestOptions.ts

@@ -0,0 +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>;
+};

package/clients/storageService/core/ApiResult.ts

@@ -0,0 +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;
+};

package/clients/storageService/core/CancelablePromise.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelablePromise = exports.CancelError = void 0;
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+exports.CancelError = CancelError;
+class CancelablePromise {
+    #isResolved;
+    #isRejected;
+    #isCancelled;
+    #cancelHandlers;
+    #promise;
+    #resolve;
+    #reject;
+    constructor(executor) {
+        this.#isResolved = false;
+        this.#isRejected = false;
+        this.#isCancelled = false;
+        this.#cancelHandlers = [];
+        this.#promise = new Promise((resolve, reject) => {
+            this.#resolve = resolve;
+            this.#reject = reject;
+            const onResolve = (value) => {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                    return;
+                }
+                this.#isResolved = true;
+                if (this.#resolve)
+                    this.#resolve(value);
+            };
+            const onReject = (reason) => {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                    return;
+                }
+                this.#isRejected = true;
+                if (this.#reject)
+                    this.#reject(reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                    return;
+                }
+                this.#cancelHandlers.push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => this.#isResolved,
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => this.#isRejected,
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => this.#isCancelled,
+            });
+            return executor(onResolve, onReject, onCancel);
+        });
+    }
+    get [Symbol.toStringTag]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return this.#promise.then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.#promise.catch(onRejected);
+    }
+    finally(onFinally) {
+        return this.#promise.finally(onFinally);
+    }
+    cancel() {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+            return;
+        }
+        this.#isCancelled = true;
+        if (this.#cancelHandlers.length) {
+            try {
+                for (const cancelHandler of this.#cancelHandlers) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        this.#cancelHandlers.length = 0;
+        if (this.#reject)
+            this.#reject(new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return this.#isCancelled;
+    }
+}
+exports.CancelablePromise = CancelablePromise;