@fenixalliance/abs-api-client 1.0.0 → 1.0.2

package/clients/tenantService/services/TenantsService.ts

@@ -2,276 +2,388 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
-import type { BusinessCreateDto } from '../models/BusinessCreateDto';
-import type { BusinessDto } from '../models/BusinessDto';
-import type { BusinessEnrollmentDto } from '../models/BusinessEnrollmentDto';
-import type { BusinessEnrollmentDtoEnvelope } from '../models/BusinessEnrollmentDtoEnvelope';
-import type { BusinessEnrollmentDtoIReadOnlyListEnvelope } from '../models/BusinessEnrollmentDtoIReadOnlyListEnvelope';
+import type { BooleanEnvelope } from '../models/BooleanEnvelope';
+import type { CartDtoEnvelope } from '../models/CartDtoEnvelope';
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
 import type { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
+import type { PlatformUserDtoListEnvelope } from '../models/PlatformUserDtoListEnvelope';
+import type { SocialProfileDtoEnvelope } from '../models/SocialProfileDtoEnvelope';
 import type { StringListEnvelope } from '../models/StringListEnvelope';
-import type { WalletDtoTaskEnvelope } from '../models/WalletDtoTaskEnvelope';
+import type { TenantCreateDto } from '../models/TenantCreateDto';
+import type { TenantDtoEnvelope } from '../models/TenantDtoEnvelope';
+import type { TenantEnrollmentDtoEnvelope } from '../models/TenantEnrollmentDtoEnvelope';
+import type { TenantEnrollmentDtoListEnvelope } from '../models/TenantEnrollmentDtoListEnvelope';
+import type { WalletDtoEnvelope } from '../models/WalletDtoEnvelope';
+import type { WebPortalDtoListEnvelope } from '../models/WebPortalDtoListEnvelope';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class TenantsService {
     /**
-     * @returns BusinessDto Success
+     * @returns TenantDtoEnvelope Success
      * @throws ApiError
      */
-    public static getApiV2TenantsCurrent(): CancelablePromise<BusinessDto> {
+    public static getApiV2TenantsRoot(): CancelablePromise<TenantDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/Root',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @returns TenantDtoEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsCurrent(): CancelablePromise<TenantDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/Current',
             errors: {
                 401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns BusinessDto Success
+     * @param tenantId
+     * @returns TenantDtoEnvelope Success
      * @throws ApiError
      */
     public static getApiV2Tenants(
-        businessId: string,
-    ): CancelablePromise<BusinessDto> {
+        tenantId: string,
+    ): CancelablePromise<TenantDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}',
+            url: '/api/v2/Tenants/{tenantId}',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
             errors: {
                 401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns WalletDtoTaskEnvelope Success
+     * @param tenantId
+     * @returns WalletDtoEnvelope Success
      * @throws ApiError
      */
     public static getApiV2TenantsWallet(
-        businessId: string,
-    ): CancelablePromise<WalletDtoTaskEnvelope> {
+        tenantId: string,
+    ): CancelablePromise<WalletDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Wallet',
+            url: '/api/v2/Tenants/{tenantId}/Wallet',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @param tenantId
+     * @returns SocialProfileDtoEnvelope Success
      * @throws ApiError
      */
     public static getApiV2TenantsSocialProfile(
-        businessId: string,
-    ): CancelablePromise<any> {
+        tenantId: string,
+    ): CancelablePromise<SocialProfileDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/SocialProfile',
+            url: '/api/v2/Tenants/{tenantId}/SocialProfile',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @param tenantId
+     * @returns CartDtoEnvelope Success
      * @throws ApiError
      */
     public static getApiV2TenantsCart(
-        businessId: string,
-    ): CancelablePromise<any> {
+        tenantId: string,
+    ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Cart',
+            url: '/api/v2/Tenants/{tenantId}/Cart',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns BusinessEnrollmentDtoIReadOnlyListEnvelope Success
+     * @param tenantId
+     * @returns PlatformUserDtoListEnvelope Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsUsers(
+        tenantId: string,
+    ): CancelablePromise<PlatformUserDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Users',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantEnrollmentDtoListEnvelope Success
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollments(
-        businessId: string,
-    ): CancelablePromise<BusinessEnrollmentDtoIReadOnlyListEnvelope> {
+        tenantId: string,
+    ): CancelablePromise<TenantEnrollmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param enrollmentId
-     * @returns BusinessEnrollmentDtoEnvelope Success
+     * @returns TenantEnrollmentDtoEnvelope Success
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollments1(
-        businessId: string,
+        tenantId: string,
         enrollmentId: string,
-    ): CancelablePromise<BusinessEnrollmentDtoEnvelope> {
+    ): CancelablePromise<TenantEnrollmentDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{enrollmentId}',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
                 'enrollmentId': enrollmentId,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param enrollmentId
-     * @returns any Success
+     * @returns StringListEnvelope Success
      * @throws ApiError
      */
-    public static getApiV2TenantsEnrollmentsLicenses(
-        businessId: string,
+    public static getApiV2TenantsEnrollmentsPermissions(
+        tenantId: string,
         enrollmentId: string,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<StringListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Licenses',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/Permissions',
             path: {
-                'businessId': businessId,
-                'enrollmentID': enrollmentId,
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param enrollmentId
-     * @returns StringListEnvelope Success
+     * @param roles
+     * @param permissions
+     * @returns BooleanEnvelope Success
      * @throws ApiError
      */
-    public static getApiV2TenantsEnrollmentsPermissions(
-        businessId: string,
+    public static getApiV2TenantsEnrollmentsPermissionsValidate(
+        tenantId: string,
         enrollmentId: string,
-    ): CancelablePromise<StringListEnvelope> {
+        roles?: Array<string>,
+        permissions?: Array<string>,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentID}/Permissions/Validate',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            query: {
+                'roles': roles,
+                'permissions': permissions,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @returns any Success
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsLicenses(
+        tenantId: string,
+        enrollmentId: string,
+    ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Permissions',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentID}/Licenses',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
                 'enrollmentID': enrollmentId,
             },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @returns any Success
      * @throws ApiError
      */
     public static getApiV2TenantsLicenses(
-        businessId: string,
+        tenantId: string,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Licenses',
+            url: '/api/v2/Tenants/{tenantId}/Licenses',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
         });
     }
     /**
      * @param requestBody
-     * @returns any Success
+     * @returns EmptyEnvelope Success
      * @throws ApiError
      */
     public static postApiV2Tenants(
-        requestBody?: BusinessCreateDto,
-    ): CancelablePromise<any> {
+        requestBody?: TenantCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/Tenants',
             body: requestBody,
             mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @param tenantId
+     * @returns EmptyEnvelope Success
      * @throws ApiError
      */
     public static deleteApiV2Tenants(
-        businessId: string,
-    ): CancelablePromise<any> {
+        tenantId: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
             url: '/api/v2/Tenants',
             query: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @returns EmptyEnvelope Success
      * @throws ApiError
      */
     public static getApiV2TenantsSelect(
-        businessId: string,
+        tenantId: string,
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Select',
+            url: '/api/v2/Tenants/{tenantId}/Select',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @returns EmptyEnvelope Success
      * @throws ApiError
      */
     public static postApiV2TenantsSelect(
-        businessId: string,
+        tenantId: string,
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/Tenants/{businessId}/Select',
+            url: '/api/v2/Tenants/{tenantId}/Select',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @returns EmptyEnvelope Success
      * @throws ApiError
      */
     public static getApiV2TenantsDeselect(
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/Deselect',
@@ -279,18 +391,22 @@ export class TenantsService {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @returns EmptyEnvelope Success
      * @throws ApiError
      */
     public static postApiV2TenantsDeselect(
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/Tenants/Deselect',
@@ -298,56 +414,65 @@ export class TenantsService {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @returns any Success
      * @throws ApiError
      */
     public static getApiV2TenantsAppAuthorization(
-        businessId: string,
+        tenantId: string,
     ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/AppAuthorization',
+            url: '/api/v2/Tenants/{tenantId}/AppAuthorization',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns NotificationDtoListEnvelope Success
+     * @param tenantId
+     * @returns WebPortalDtoListEnvelope Success
      * @throws ApiError
      */
-    public static getApiV2TenantsNotifications(
-        businessId: string,
-    ): CancelablePromise<NotificationDtoListEnvelope> {
+    public static getApiV2TenantsWebPortals(
+        tenantId: string,
+    ): CancelablePromise<WebPortalDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Notifications',
+            url: '/api/v2/Tenants/{tenantId}/WebPortals',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns BusinessEnrollmentDto Success
+     * @param tenantId
+     * @returns NotificationDtoListEnvelope Success
      * @throws ApiError
      */
-    public static getApiV2TenantsUserEnrollments(
-        businessId: string,
-    ): CancelablePromise<Array<BusinessEnrollmentDto>> {
+    public static getApiV2TenantsNotifications(
+        tenantId: string,
+    ): CancelablePromise<NotificationDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/UserEnrollments',
+            url: '/api/v2/Tenants/{tenantId}/Notifications',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
             errors: {
                 401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }

package/clients/walletsService/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/walletsService/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/walletsService/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;
+};