@fenixalliance/abs-api-client 1.0.0

package/clients/catalogService/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/catalogService/services/ItemAttachmentsService.ts

@@ -0,0 +1,127 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemAttachmentCreateDto } from '../models/ItemAttachmentCreateDto';
+import type { ItemAttachmentDtoEnvelope } from '../models/ItemAttachmentDtoEnvelope';
+import type { ItemAttachmentDtoIReadOnlyCollectionEnvelope } from '../models/ItemAttachmentDtoIReadOnlyCollectionEnvelope';
+import type { ItemAttachmentUpdateDto } from '../models/ItemAttachmentUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemAttachmentsService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns ItemAttachmentDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemAttachmentsCreate(
+        businessId: string,
+        requestBody?: ItemAttachmentCreateDto,
+    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemAttachments/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemAttachmentId
+     * @returns ItemAttachmentDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemAttachmentsDetails(
+        itemAttachmentId: string,
+    ): CancelablePromise<ItemAttachmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemAttachments/Details/{itemAttachmentId}',
+            path: {
+                'itemAttachmentId': itemAttachmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemAttachmentDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemAttachmentsList(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemAttachmentDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemAttachments/List',
+            query: {
+                'businessId': businessId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemAttachmentId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemAttachmentsDelete(
+        itemAttachmentId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemAttachments/Delete/{itemAttachmentId}',
+            path: {
+                'itemAttachmentId': itemAttachmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemAttachmentId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemAttachmentsUpdate(
+        itemAttachmentId: string,
+        requestBody?: ItemAttachmentUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemAttachments/Update/{itemAttachmentId}',
+            path: {
+                'itemAttachmentId': itemAttachmentId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemAttributesService.ts

@@ -0,0 +1,127 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemAttributeCreateDto } from '../models/ItemAttributeCreateDto';
+import type { ItemAttributeDtoEnvelope } from '../models/ItemAttributeDtoEnvelope';
+import type { ItemAttributeDtoIReadOnlyCollectionEnvelope } from '../models/ItemAttributeDtoIReadOnlyCollectionEnvelope';
+import type { ItemAttributeUpdateDto } from '../models/ItemAttributeUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemAttributesService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns ItemAttributeDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemAttributesCreate(
+        businessId: string,
+        requestBody?: ItemAttributeCreateDto,
+    ): CancelablePromise<ItemAttributeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemAttributes/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemAttributeId
+     * @returns ItemAttributeDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemAttributesDetails(
+        itemAttributeId: string,
+    ): CancelablePromise<ItemAttributeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemAttributes/Details/{itemAttributeId}',
+            path: {
+                'itemAttributeId': itemAttributeId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemAttributeDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemAttributesList(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemAttributeDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemAttributes/List',
+            query: {
+                'businessId': businessId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemAttributeId
+     * @param requestBody
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemAttributesUpdate(
+        itemAttributeId: string,
+        requestBody?: ItemAttributeUpdateDto,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemAttributes/Update/{itemAttributeId}',
+            path: {
+                'itemAttributeId': itemAttributeId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemAttributeId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemAttributesDelete(
+        itemAttributeId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemAttributes/Delete/{itemAttributeId}',
+            path: {
+                'itemAttributeId': itemAttributeId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/catalogService/services/ItemBrandsService.ts

@@ -0,0 +1,127 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ItemBrandCreateDto } from '../models/ItemBrandCreateDto';
+import type { ItemBrandDtoEnvelope } from '../models/ItemBrandDtoEnvelope';
+import type { ItemBrandDtoIReadOnlyCollectionEnvelope } from '../models/ItemBrandDtoIReadOnlyCollectionEnvelope';
+import type { ItemBrandUpdateDto } from '../models/ItemBrandUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ItemBrandsService {
+    /**
+     * @param businessId
+     * @param requestBody
+     * @returns ItemBrandDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2CatalogServiceItemBrandsCreate(
+        businessId: string,
+        requestBody?: ItemBrandCreateDto,
+    ): CancelablePromise<ItemBrandDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/CatalogService/ItemBrands/Create',
+            query: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemBrandId
+     * @returns ItemBrandDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemBrandsDetails(
+        itemBrandId: string,
+    ): CancelablePromise<ItemBrandDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemBrands/Details/{itemBrandId}',
+            path: {
+                'itemBrandId': itemBrandId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param businessId
+     * @param pageNumber
+     * @param pageSize
+     * @returns ItemBrandDtoIReadOnlyCollectionEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2CatalogServiceItemBrandsList(
+        businessId: string,
+        pageNumber?: number,
+        pageSize?: number,
+    ): CancelablePromise<ItemBrandDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/CatalogService/ItemBrands/List',
+            query: {
+                'businessId': businessId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemBrandId
+     * @param requestBody
+     * @returns ItemBrandDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static putApiV2CatalogServiceItemBrandsUpdate(
+        itemBrandId: string,
+        requestBody?: ItemBrandUpdateDto,
+    ): CancelablePromise<ItemBrandDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/CatalogService/ItemBrands/Update/{itemBrandId}',
+            path: {
+                'itemBrandId': itemBrandId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param itemBrandId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static deleteApiV2CatalogServiceItemBrandsDelete(
+        itemBrandId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/CatalogService/ItemBrands/Delete/{itemBrandId}',
+            path: {
+                'itemBrandId': itemBrandId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}