@fenixalliance/abs-api-client 1.0.5 → 1.0.6

package/clients/walletsService/services/FenixAllianceAbsModulesWebService.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 FenixAllianceAbsModulesWebService {
+    /**
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static getVersion(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/version',
+        });
+    }
+    /**
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static getHealth(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/health',
+        });
+    }
+    /**
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static getHello(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/hello',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns any OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @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 OK
+     * @throws ApiError
+     */
+    public static postAccountManageDownloadPersonalData(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/Account/Manage/DownloadPersonalData',
+        });
+    }
+}

package/clients/walletsService/services/WalletsService.ts

@@ -2,8 +2,14 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { ExtendedOrderDtoListEnvelope } from '../models/ExtendedOrderDtoListEnvelope';
+import type { Int32Envelope } from '../models/Int32Envelope';
 import type { InvoiceDtoListEnvelope } from '../models/InvoiceDtoListEnvelope';
+import type { LocationCreateDto } from '../models/LocationCreateDto';
+import type { LocationDtoEnvelope } from '../models/LocationDtoEnvelope';
 import type { LocationDtoListEnvelope } from '../models/LocationDtoListEnvelope';
+import type { LocationUpdateDto } from '../models/LocationUpdateDto';
 import type { OrderDtoListEnvelope } from '../models/OrderDtoListEnvelope';
 import type { PaymentDtoListEnvelope } from '../models/PaymentDtoListEnvelope';
 import type { WalletDtoEnvelope } from '../models/WalletDtoEnvelope';
@@ -61,6 +67,56 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns ExtendedOrderDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsOrdersExtended(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedOrderDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Orders/Extended',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsOrdersCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Orders/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param walletId
      * @param xApiVersion
@@ -86,6 +142,31 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsInvoicesCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Invoices/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param walletId
      * @param xApiVersion
@@ -111,6 +192,31 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsPaymentsCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Payments/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param walletId
      * @param xApiVersion
@@ -136,6 +242,148 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2WalletsServiceWalletsLocations(
+        walletId: string,
+        xApiVersion?: string,
+        requestBody?: LocationCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Locations',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsLocationsCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Locations/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param walletId
+     * @param locationId
+     * @param xApiVersion
+     * @returns LocationDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getWalletLocationAsync(
+        walletId: string,
+        locationId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<LocationDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Locations/{locationId}',
+            path: {
+                'walletId': walletId,
+                'locationId': locationId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param walletId
+     * @param locationId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2WalletsServiceWalletsLocations(
+        walletId: string,
+        locationId: string,
+        xApiVersion?: string,
+        requestBody?: LocationUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Locations/{locationId}',
+            path: {
+                'walletId': walletId,
+                'locationId': locationId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param walletId
+     * @param locationId
+     * @param xApiVersion
+     * @returns void
+     * @throws ApiError
+     */
+    public static deleteApiV2WalletsServiceWalletsLocations(
+        walletId: string,
+        locationId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Locations/{locationId}',
+            path: {
+                'walletId': walletId,
+                'locationId': locationId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param walletId
      * @param xApiVersion
@@ -161,6 +409,31 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsInvoicesIncomingCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Invoices/Incoming/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param walletId
      * @param xApiVersion
@@ -186,6 +459,31 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsInvoicesOutgoingCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Invoices/Outgoing/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param walletId
      * @param xApiVersion
@@ -211,6 +509,31 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsPaymentsIncomingCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Payments/Incoming/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param walletId
      * @param xApiVersion
@@ -236,4 +559,29 @@ export class WalletsService {
             },
         });
     }
+    /**
+     * @param walletId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2WalletsServiceWalletsPaymentsOutgoingCount(
+        walletId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/WalletsService/Wallets/{walletId}/Payments/Outgoing/Count',
+            path: {
+                'walletId': walletId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "license": "MIT",
   "access": "public",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "name": "@fenixalliance/abs-api-client",
   "main": "wwwroot/build/bundle.js",
   "homepage": "https://absuite.net",