@fenixalliance/abs-api-client 1.0.0

package/clients/cartService/services/CompareService.ts

@@ -0,0 +1,89 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AddProductToCompareRequest } from '../models/AddProductToCompareRequest';
+import type { ItemCartRecordDto } from '../models/ItemCartRecordDto';
+import type { ItemToCompareCartRecordDto } from '../models/ItemToCompareCartRecordDto';
+import type { ItemToCompareCartRecordDtoEnvelope } from '../models/ItemToCompareCartRecordDtoEnvelope';
+import type { ItemToCompareCartRecordDtoIReadOnlyListEnvelope } from '../models/ItemToCompareCartRecordDtoIReadOnlyListEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class CompareService {
+    /**
+     * @param cartId
+     * @returns ItemToCompareCartRecordDtoIReadOnlyListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCompare(
+        cartId: string,
+    ): CancelablePromise<ItemToCompareCartRecordDtoIReadOnlyListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Compare/{cartId}',
+            path: {
+                'cartId': cartId,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param recordId
+     * @returns ItemToCompareCartRecordDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceCompareDetails(
+        recordId: string,
+    ): CancelablePromise<ItemToCompareCartRecordDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Compare/{recordId}/Details',
+            path: {
+                'recordId': recordId,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns ItemCartRecordDto Success
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceCompare(
+        requestBody?: AddProductToCompareRequest,
+    ): CancelablePromise<ItemCartRecordDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Compare',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param recordId
+     * @returns ItemToCompareCartRecordDto Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceCompare(
+        recordId: string,
+    ): CancelablePromise<ItemToCompareCartRecordDto> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Compare/{recordId}',
+            path: {
+                'recordId': recordId,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+}

package/clients/cartService/services/FenixAllianceAbsWebService.ts

@@ -0,0 +1,293 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AccessTokenResponse } from '../models/AccessTokenResponse';
+import type { ForgotPasswordRequest } from '../models/ForgotPasswordRequest';
+import type { InfoRequest } from '../models/InfoRequest';
+import type { InfoResponse } from '../models/InfoResponse';
+import type { LoginRequest } from '../models/LoginRequest';
+import type { RefreshRequest } from '../models/RefreshRequest';
+import type { RegisterRequest } from '../models/RegisterRequest';
+import type { ResendConfirmationEmailRequest } from '../models/ResendConfirmationEmailRequest';
+import type { ResetPasswordRequest } from '../models/ResetPasswordRequest';
+import type { TwoFactorRequest } from '../models/TwoFactorRequest';
+import type { TwoFactorResponse } from '../models/TwoFactorResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class FenixAllianceAbsWebService {
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getVersion(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/version',
+        });
+    }
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getHealth(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/health',
+        });
+    }
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getHello(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/hello',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postRegister(
+        requestBody?: RegisterRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/register',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+            },
+        });
+    }
+    /**
+     * @param useCookies
+     * @param useSessionCookies
+     * @param requestBody
+     * @returns AccessTokenResponse Success
+     * @throws ApiError
+     */
+    public static postLogin(
+        useCookies?: boolean,
+        useSessionCookies?: boolean,
+        requestBody?: LoginRequest,
+    ): CancelablePromise<AccessTokenResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/login',
+            query: {
+                'useCookies': useCookies,
+                'useSessionCookies': useSessionCookies,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns AccessTokenResponse Success
+     * @throws ApiError
+     */
+    public static postRefresh(
+        requestBody?: RefreshRequest,
+    ): CancelablePromise<AccessTokenResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/refresh',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param userId
+     * @param code
+     * @param changedEmail
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static mapIdentityApiConfirmEmail(
+        userId?: string,
+        code?: string,
+        changedEmail?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/confirmEmail',
+            query: {
+                'userId': userId,
+                'code': code,
+                'changedEmail': changedEmail,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postResendConfirmationEmail(
+        requestBody?: ResendConfirmationEmailRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/resendConfirmationEmail',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postForgotPassword(
+        requestBody?: ForgotPasswordRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/forgotPassword',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postResetPassword(
+        requestBody?: ResetPasswordRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/resetPassword',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns TwoFactorResponse Success
+     * @throws ApiError
+     */
+    public static postManage2Fa(
+        requestBody?: TwoFactorRequest,
+    ): CancelablePromise<TwoFactorResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/manage/2fa',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @returns InfoResponse Success
+     * @throws ApiError
+     */
+    public static getManageInfo(): CancelablePromise<InfoResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/manage/info',
+            errors: {
+                400: `Bad Request`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns InfoResponse Success
+     * @throws ApiError
+     */
+    public static postManageInfo(
+        requestBody?: InfoRequest,
+    ): CancelablePromise<InfoResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/manage/info',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountPerformExternalLogin(
+        formData?: {
+            provider: string;
+            returnUrl: string;
+        },
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/PerformExternalLogin',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+        });
+    }
+    /**
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountLogout(
+        formData?: {
+            returnUrl: string;
+        },
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/Logout',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+        });
+    }
+    /**
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountManageLinkExternalLogin(
+        formData?: {
+            provider: string;
+        },
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/Manage/LinkExternalLogin',
+            formData: formData,
+            mediaType: 'multipart/form-data',
+        });
+    }
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postAccountManageDownloadPersonalData(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/Manage/DownloadPersonalData',
+        });
+    }
+}

package/clients/cartService/services/RecordsService.ts

@@ -0,0 +1,206 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BooleanEnvelope } from '../models/BooleanEnvelope';
+import type { Envelope } from '../models/Envelope';
+import type { ItemCartRecordCreateDto } from '../models/ItemCartRecordCreateDto';
+import type { ItemCartRecordDto } from '../models/ItemCartRecordDto';
+import type { ItemCartRecordDtoEnvelope } from '../models/ItemCartRecordDtoEnvelope';
+import type { ItemCartRecordUpdateDto } from '../models/ItemCartRecordUpdateDto';
+import type { ProductCartRecordDto } from '../models/ProductCartRecordDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class RecordsService {
+    /**
+     * @param cartId
+     * @param itemId
+     * @param quantity
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceRecordsAddItem(
+        cartId?: string,
+        itemId?: string,
+        quantity?: number,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Records/AddItem',
+            query: {
+                'cartId': cartId,
+                'itemId': itemId,
+                'quantity': quantity,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @returns ProductCartRecordDto Success
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceRecords(
+        cartId: string,
+    ): CancelablePromise<Array<ProductCartRecordDto>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Records/{cartID}',
+            path: {
+                'cartId': cartId,
+            },
+            errors: {
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns ItemCartRecordDto Success
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceRecords(
+        requestBody?: ItemCartRecordCreateDto,
+    ): CancelablePromise<ItemCartRecordDto> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Records',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @param productId
+     * @returns Envelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceRecords(
+        cartId?: string,
+        productId?: string,
+    ): CancelablePromise<Envelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Records',
+            query: {
+                'cartId': cartId,
+                'productId': productId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param itemId
+     * @param cartId
+     * @returns BooleanEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceRecordsIsInCart(
+        itemId: string,
+        cartId: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Records/IsInCart',
+            query: {
+                'itemID': itemId,
+                'cartID': cartId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param cartId
+     * @returns BooleanEnvelope Success
+     * @throws ApiError
+     */
+    public static postApiV2CartServiceRecordsClearCart(
+        cartId: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CartService/Records/ClearCart',
+            query: {
+                'cartID': cartId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param recordId
+     * @returns ItemCartRecordDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CartServiceRecordsDetails(
+        recordId: string,
+    ): CancelablePromise<ItemCartRecordDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CartService/Records/{recordId}/Details',
+            path: {
+                'recordId': recordId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param recordId
+     * @param requestBody
+     * @returns ItemCartRecordDto Success
+     * @throws ApiError
+     */
+    public static putApiV2CartServiceRecords(
+        recordId: string,
+        requestBody?: ItemCartRecordUpdateDto,
+    ): CancelablePromise<ItemCartRecordDto> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CartService/Records/{recordId}',
+            path: {
+                'recordId': recordId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+    /**
+     * @param recordId
+     * @returns Envelope Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CartServiceRecords1(
+        recordId: string,
+    ): CancelablePromise<Envelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CartService/Records/{recordId}',
+            path: {
+                'recordId': recordId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                404: `Not Found`,
+            },
+        });
+    }
+}