@fenixalliance/abs-api-client 1.0.12 → 1.0.14

package/clients/{holderService/services/TenantsService.js → authService/services/OAuthService.js}

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TenantsService = void 0;
+exports.OAuthService = void 0;
 const OpenAPI_1 = require("../core/OpenAPI");
 const request_1 = require("../core/request");
-class TenantsService {
+class OAuthService {
     /**
-     * Get the tenants that the current user is enrolled in
-     * Get the tenants that the current user is enrolled in
+     * @param tenantId
      * @param xApiVersion
-     * @returns TenantDtoListEnvelope OK
+     * @returns ApiAuthorizationResultEnvelope OK
      * @throws ApiError
      */
-    static getCurrentUserTenantsAsync(xApiVersion) {
+    static getApiV2OAuthWhoAmI(tenantId, xApiVersion) {
         return (0, request_1.request)(OpenAPI_1.OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Businesses',
+            url: '/api/v2/OAuth/WhoAmI',
             headers: {
                 'x-api-version': xApiVersion,
             },
+            query: {
+                'tenantId': tenantId,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -25,19 +27,20 @@ class TenantsService {
         });
     }
     /**
-     * Count the tenants that the current user is enrolled in
-     * Count the tenants that the current user is enrolled in
      * @param xApiVersion
-     * @returns Int32Envelope OK
+     * @param requestBody
+     * @returns JsonWebTokenEnvelope OK
      * @throws ApiError
      */
-    static countCurrentUserTenantsAsync(xApiVersion) {
+    static postApiV2OAuthToken(xApiVersion, requestBody) {
         return (0, request_1.request)(OpenAPI_1.OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Businesses/Count',
+            method: 'POST',
+            url: '/api/v2/OAuth/Token',
             headers: {
                 'x-api-version': xApiVersion,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -45,19 +48,23 @@ class TenantsService {
         });
     }
     /**
-     * Get the tenants that the current user is enrolled in
-     * Get the tenants that the current user is enrolled in
+     * @param tenantId
+     * @param userId
      * @param xApiVersion
-     * @returns ExtendedTenantDtoListEnvelope OK
+     * @returns StringListEnvelope OK
      * @throws ApiError
      */
-    static getCurrentUserTenantsExtendedAsync(xApiVersion) {
+    static getApiV2OAuthPermissions(tenantId, userId, xApiVersion) {
         return (0, request_1.request)(OpenAPI_1.OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Businesses/Extended',
+            url: '/api/v2/OAuth/Permissions',
             headers: {
                 'x-api-version': xApiVersion,
             },
+            query: {
+                'tenantId': tenantId,
+                'userId': userId,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -65,87 +72,81 @@ class TenantsService {
         });
     }
     /**
-     * Get the list of enrollments for the current user
-     * Get the list of enrollments for the current user
      * @param xApiVersion
-     * @returns TenantEnrolmentDtoListEnvelope OK
+     * @param requestBody
+     * @returns JsonWebTokenEnvelope OK
      * @throws ApiError
      */
-    static getCurrentUserEnrollmentsAsync(xApiVersion) {
+    static postApiV2OAuthSignIn(xApiVersion, requestBody) {
         return (0, request_1.request)(OpenAPI_1.OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Me/Enrollments',
+            method: 'POST',
+            url: '/api/v2/OAuth/SignIn',
             headers: {
                 'x-api-version': xApiVersion,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
+                400: `Bad Request`,
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * Get the list of enrollments for the current user
-     * Get the list of enrollments for the current user
      * @param xApiVersion
-     * @returns ExtendedTenantEnrolmentDtoListEnvelope OK
+     * @returns AccountHolderCreateDtoEnvelope OK
      * @throws ApiError
      */
-    static getCurrentUserEnrollmentsExtendedAsync(xApiVersion) {
+    static getApiV2OAuthSignIn(xApiVersion) {
         return (0, request_1.request)(OpenAPI_1.OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Enrollments/Extended',
+            url: '/api/v2/OAuth/SignIn',
             headers: {
                 'x-api-version': xApiVersion,
             },
             errors: {
+                400: `Bad Request`,
                 401: `Unauthorized`,
             },
         });
     }
     /**
-     * Get a single TenantEnrollment by its ID
-     * Get a single TenantEnrollment by its ID
-     * @param enrollmentId
+     * @param applicationId
      * @param xApiVersion
-     * @param requestBody
-     * @returns TenantEnrolmentDtoEnvelope OK
+     * @returns JsonWebKeySetEnvelope OK
      * @throws ApiError
      */
-    static getTenantEnrollmentAsync(enrollmentId, xApiVersion, requestBody) {
+    static getApiV2OAuthKeys(applicationId, xApiVersion) {
         return (0, request_1.request)(OpenAPI_1.OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Enrollments/{enrollmentId}',
+            url: '/api/v2/OAuth/{applicationId}/Keys',
             path: {
-                'enrollmentId': enrollmentId,
+                'applicationId': applicationId,
             },
             headers: {
                 'x-api-version': xApiVersion,
             },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                401: `Unauthorized`,
-            },
         });
     }
     /**
-     * Get the list of tenant enrollment invitations for the current user
-     * Get the list of tenant enrollment invitations for the current user
+     * @param tenantId
+     * @param applicationId
      * @param xApiVersion
-     * @returns TenantInvitationDtoListEnvelope OK
+     * @returns OpenIdConfigurationEnvelope OK
      * @throws ApiError
      */
-    static getCurrentUserInvitationAsync(xApiVersion) {
+    static getApiV2OAuthWellKnownOpenIdConfiguration(tenantId, applicationId, xApiVersion) {
         return (0, request_1.request)(OpenAPI_1.OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Me/Invitations',
+            url: '/api/v2/OAuth/{tenantId}/{applicationId}/.Well-Known/OpenId-Configuration',
+            path: {
+                'tenantId': tenantId,
+                'applicationId': applicationId,
+            },
             headers: {
                 'x-api-version': xApiVersion,
             },
-            errors: {
-                401: `Unauthorized`,
-            },
         });
     }
 }
-exports.TenantsService = TenantsService;
+exports.OAuthService = OAuthService;

package/clients/authService/services/OAuthService.ts

@@ -0,0 +1,183 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AccountHolderCreateDtoEnvelope } from '../models/AccountHolderCreateDtoEnvelope';
+import type { ApiAuthorizationResultEnvelope } from '../models/ApiAuthorizationResultEnvelope';
+import type { JsonWebKeySetEnvelope } from '../models/JsonWebKeySetEnvelope';
+import type { JsonWebTokenEnvelope } from '../models/JsonWebTokenEnvelope';
+import type { OAuthTokenRequest } from '../models/OAuthTokenRequest';
+import type { OpenIdConfigurationEnvelope } from '../models/OpenIdConfigurationEnvelope';
+import type { SigninModel } from '../models/SigninModel';
+import type { StringListEnvelope } from '../models/StringListEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class OAuthService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns ApiAuthorizationResultEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2OAuthWhoAmI(
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ApiAuthorizationResultEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/OAuth/WhoAmI',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @param requestBody
+     * @returns JsonWebTokenEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2OAuthToken(
+        xApiVersion?: string,
+        requestBody?: OAuthTokenRequest,
+    ): CancelablePromise<JsonWebTokenEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/OAuth/Token',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param userId
+     * @param xApiVersion
+     * @returns StringListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2OAuthPermissions(
+        tenantId: string,
+        userId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<StringListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/OAuth/Permissions',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'userId': userId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @param requestBody
+     * @returns JsonWebTokenEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2OAuthSignIn(
+        xApiVersion?: string,
+        requestBody?: SigninModel,
+    ): CancelablePromise<JsonWebTokenEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/OAuth/SignIn',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns AccountHolderCreateDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2OAuthSignIn(
+        xApiVersion?: string,
+    ): CancelablePromise<AccountHolderCreateDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/OAuth/SignIn',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                400: `Bad Request`,
+                401: `Unauthorized`,
+            },
+        });
+    }
+    /**
+     * @param applicationId
+     * @param xApiVersion
+     * @returns JsonWebKeySetEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2OAuthKeys(
+        applicationId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<JsonWebKeySetEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/OAuth/{applicationId}/Keys',
+            path: {
+                'applicationId': applicationId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param applicationId
+     * @param xApiVersion
+     * @returns OpenIdConfigurationEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2OAuthWellKnownOpenIdConfiguration(
+        tenantId: string,
+        applicationId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<OpenIdConfigurationEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/OAuth/{tenantId}/{applicationId}/.Well-Known/OpenId-Configuration',
+            path: {
+                'tenantId': tenantId,
+                'applicationId': applicationId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+}

package/clients/authService/services/ResourceService.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class ResourceService {
+    /**
+     * @param xApiVersion
+     * @returns any OK
+     * @throws ApiError
+     */
+    static getApiV2IdentityServiceResourceMessage(xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/IdentityService/Resource/message',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+}
+exports.ResourceService = ResourceService;

package/clients/authService/services/ResourceService.ts

@@ -0,0 +1,25 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ResourceService {
+    /**
+     * @param xApiVersion
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static getApiV2IdentityServiceResourceMessage(
+        xApiVersion?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/IdentityService/Resource/message',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+}

package/clients/authService/services/UserInfoService.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserInfoService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class UserInfoService {
+    /**
+     * @param xApiVersion
+     * @returns any OK
+     * @throws ApiError
+     */
+    static getConnectUserinfo(xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/connect/userinfo',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns any OK
+     * @throws ApiError
+     */
+    static postConnectUserinfo(xApiVersion) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/connect/userinfo',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+}
+exports.UserInfoService = UserInfoService;

package/clients/authService/services/UserInfoService.ts

@@ -0,0 +1,41 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class UserInfoService {
+    /**
+     * @param xApiVersion
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static getConnectUserinfo(
+        xApiVersion?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/connect/userinfo',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+    /**
+     * @param xApiVersion
+     * @returns any OK
+     * @throws ApiError
+     */
+    public static postConnectUserinfo(
+        xApiVersion?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/connect/userinfo',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+        });
+    }
+}

package/clients/cartService/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WishListsService = exports.RecordsService = exports.ECommerceService = exports.CompareService = exports.CartLinesService = exports.CartService = exports.ItemCartRecordDto = exports.OpenAPI = exports.CancelError = exports.CancelablePromise = exports.ApiError = void 0;
+exports.WishListsService = exports.RecordsService = exports.CompareService = exports.CartsService = exports.ItemCartRecordDto = exports.OpenAPI = exports.CancelError = exports.CancelablePromise = exports.ApiError = void 0;
 /* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
 /* tslint:disable */
@@ -14,14 +14,10 @@ var OpenAPI_1 = require("./core/OpenAPI");
 Object.defineProperty(exports, "OpenAPI", { enumerable: true, get: function () { return OpenAPI_1.OpenAPI; } });
 var ItemCartRecordDto_1 = require("./models/ItemCartRecordDto");
 Object.defineProperty(exports, "ItemCartRecordDto", { enumerable: true, get: function () { return ItemCartRecordDto_1.ItemCartRecordDto; } });
-var CartService_1 = require("./services/CartService");
-Object.defineProperty(exports, "CartService", { enumerable: true, get: function () { return CartService_1.CartService; } });
-var CartLinesService_1 = require("./services/CartLinesService");
-Object.defineProperty(exports, "CartLinesService", { enumerable: true, get: function () { return CartLinesService_1.CartLinesService; } });
+var CartsService_1 = require("./services/CartsService");
+Object.defineProperty(exports, "CartsService", { enumerable: true, get: function () { return CartsService_1.CartsService; } });
 var CompareService_1 = require("./services/CompareService");
 Object.defineProperty(exports, "CompareService", { enumerable: true, get: function () { return CompareService_1.CompareService; } });
-var ECommerceService_1 = require("./services/ECommerceService");
-Object.defineProperty(exports, "ECommerceService", { enumerable: true, get: function () { return ECommerceService_1.ECommerceService; } });
 var RecordsService_1 = require("./services/RecordsService");
 Object.defineProperty(exports, "RecordsService", { enumerable: true, get: function () { return RecordsService_1.RecordsService; } });
 var WishListsService_1 = require("./services/WishListsService");

package/clients/cartService/index.ts

@@ -35,9 +35,7 @@ export type { WishListDtoEnvelope } from './models/WishListDtoEnvelope';
 export type { WishListItemRecordDto } from './models/WishListItemRecordDto';
 export type { WishListUpdateDto } from './models/WishListUpdateDto';
 
-export { CartService } from './services/CartService';
-export { CartLinesService } from './services/CartLinesService';
+export { CartsService } from './services/CartsService';
 export { CompareService } from './services/CompareService';
-export { ECommerceService } from './services/ECommerceService';
 export { RecordsService } from './services/RecordsService';
 export { WishListsService } from './services/WishListsService';

package/clients/cartService/services/{CartService.js → CartsService.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CartService = void 0;
+exports.CartsService = void 0;
 const OpenAPI_1 = require("../core/OpenAPI");
 const request_1 = require("../core/request");
-class CartService {
+class CartsService {
     /**
      * Get all business owned contacts
      * Get all business owned contacts
@@ -1101,4 +1101,4 @@ class CartService {
         });
     }
 }
-exports.CartService = CartService;
+exports.CartsService = CartsService;

package/clients/cartService/services/{CartService.ts → CartsService.ts}

@@ -25,7 +25,7 @@ import type { WishListUpdateDto } from '../models/WishListUpdateDto';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
-export class CartService {
+export class CartsService {
     /**
      * Get all business owned contacts
      * Get all business owned contacts