@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/tenantService/services/TenantsService.ts

@@ -5,14 +5,22 @@
 import type { BooleanEnvelope } from '../models/BooleanEnvelope';
 import type { CartDtoEnvelope } from '../models/CartDtoEnvelope';
 import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { ExtendedTenantDtoEnvelope } from '../models/ExtendedTenantDtoEnvelope';
+import type { ExtendedTenantEnrolmentDtoEnvelope } from '../models/ExtendedTenantEnrolmentDtoEnvelope';
 import type { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
+import type { Operation } from '../models/Operation';
 import type { PlatformUserDtoListEnvelope } from '../models/PlatformUserDtoListEnvelope';
 import type { SocialProfileDtoEnvelope } from '../models/SocialProfileDtoEnvelope';
 import type { StringListEnvelope } from '../models/StringListEnvelope';
+import type { SuiteLicenseAssignmentDtoListEnvelope } from '../models/SuiteLicenseAssignmentDtoListEnvelope';
+import type { SuiteLicenseDtoListEnvelope } from '../models/SuiteLicenseDtoListEnvelope';
+import type { SuiteLicenseFeatureDtoListEnvelope } from '../models/SuiteLicenseFeatureDtoListEnvelope';
 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 { TenantEnrolmentDtoEnvelope } from '../models/TenantEnrolmentDtoEnvelope';
+import type { TenantEnrolmentDtoListEnvelope } from '../models/TenantEnrolmentDtoListEnvelope';
+import type { TenantInvitationDtoListEnvelope } from '../models/TenantInvitationDtoListEnvelope';
+import type { TenantUpdateDto } from '../models/TenantUpdateDto';
 import type { WalletDtoEnvelope } from '../models/WalletDtoEnvelope';
 import type { WebPortalDtoListEnvelope } from '../models/WebPortalDtoListEnvelope';
 import type { CancelablePromise } from '../core/CancelablePromise';
@@ -20,13 +28,19 @@ import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class TenantsService {
     /**
-     * @returns TenantDtoEnvelope Success
+     * @param xApiVersion
+     * @returns TenantDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2TenantsRoot(): CancelablePromise<TenantDtoEnvelope> {
+    public static getApiV2TenantsRoot(
+        xApiVersion?: string,
+    ): CancelablePromise<TenantDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/Root',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -34,13 +48,24 @@ export class TenantsService {
         });
     }
     /**
-     * @returns TenantDtoEnvelope Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2TenantsCurrent(): CancelablePromise<TenantDtoEnvelope> {
+    public static getApiV2TenantsCurrent(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/Current',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -49,11 +74,13 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns TenantDtoEnvelope Success
+     * @param xApiVersion
+     * @returns TenantDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2Tenants(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<TenantDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -61,6 +88,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -69,11 +99,152 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns WalletDtoEnvelope Success
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Tenants(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: TenantUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Tenants/{tenantId}',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Tenants(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Tenants/{tenantId}',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns ExtendedTenantDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsExtended(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedTenantDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Extended',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsAvatar(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Avatar',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param formData
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2TenantsAvatar(
+        tenantId: string,
+        xApiVersion?: string,
+        formData?: {
+            avatar?: Blob;
+        },
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/{tenantId}/Avatar',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns WalletDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsWallet(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<WalletDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -81,6 +252,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -89,11 +263,13 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns SocialProfileDtoEnvelope Success
+     * @param xApiVersion
+     * @returns SocialProfileDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsSocialProfile(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<SocialProfileDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -101,6 +277,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -109,11 +288,13 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns CartDtoEnvelope Success
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsCart(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<CartDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -121,6 +302,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -129,11 +313,13 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns PlatformUserDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns PlatformUserDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsUsers(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<PlatformUserDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -141,6 +327,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -149,18 +338,23 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns TenantEnrollmentDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns TenantEnrolmentDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollments(
         tenantId: string,
-    ): CancelablePromise<TenantEnrollmentDtoListEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<TenantEnrolmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/{tenantId}/Enrollments',
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -170,13 +364,15 @@ export class TenantsService {
     /**
      * @param tenantId
      * @param enrollmentId
-     * @returns TenantEnrollmentDtoEnvelope Success
+     * @param xApiVersion
+     * @returns TenantEnrolmentDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollments1(
         tenantId: string,
         enrollmentId: string,
-    ): CancelablePromise<TenantEnrollmentDtoEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<TenantEnrolmentDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}',
@@ -184,6 +380,37 @@ export class TenantsService {
                 'tenantId': tenantId,
                 'enrollmentId': enrollmentId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param xApiVersion
+     * @returns ExtendedTenantEnrolmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsExtended(
+        tenantId: string,
+        enrollmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedTenantEnrolmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/Extended',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -193,12 +420,14 @@ export class TenantsService {
     /**
      * @param tenantId
      * @param enrollmentId
-     * @returns StringListEnvelope Success
+     * @param xApiVersion
+     * @returns StringListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollmentsPermissions(
         tenantId: string,
         enrollmentId: string,
+        xApiVersion?: string,
     ): CancelablePromise<StringListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -207,6 +436,9 @@ export class TenantsService {
                 'tenantId': tenantId,
                 'enrollmentId': enrollmentId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -218,7 +450,8 @@ export class TenantsService {
      * @param enrollmentId
      * @param roles
      * @param permissions
-     * @returns BooleanEnvelope Success
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollmentsPermissionsValidate(
@@ -226,6 +459,7 @@ export class TenantsService {
         enrollmentId: string,
         roles?: Array<string>,
         permissions?: Array<string>,
+        xApiVersion?: string,
     ): CancelablePromise<BooleanEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -234,6 +468,9 @@ export class TenantsService {
                 'tenantId': tenantId,
                 'enrollmentId': enrollmentId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'roles': roles,
                 'permissions': permissions,
@@ -244,52 +481,327 @@ export class TenantsService {
             },
         });
     }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitations(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitationsPending(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations/Pending',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitationsRedeemed(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations/Redeemed',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitationsRevoked(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations/Revoked',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsLicenses(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Licenses',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
     /**
      * @param tenantId
      * @param enrollmentId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns SuiteLicenseAssignmentDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollmentsLicenses(
         tenantId: string,
         enrollmentId: string,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseAssignmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentID}/Licenses',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses',
             path: {
                 'tenantId': tenantId,
-                'enrollmentID': enrollmentId,
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
      * @param tenantId
-     * @returns any Success
+     * @param enrollmentId
+     * @param licenseId
+     * @param xApiVersion
+     * @returns SuiteLicenseDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2TenantsLicenses(
+    public static getApiV2TenantsEnrollmentsLicenses1(
         tenantId: string,
-    ): CancelablePromise<any> {
+        enrollmentId: string,
+        licenseId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{tenantId}/Licenses',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses/{licenseId}',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param licenseId
+     * @param xApiVersion
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2TenantsEnrollmentsLicenses(
+        tenantId: string,
+        enrollmentId: string,
+        licenseId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses/{licenseId}',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param licenseId
+     * @param xApiVersion
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2TenantsEnrollmentsLicenses(
+        tenantId: string,
+        enrollmentId: string,
+        licenseId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses/{licenseId}',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param xApiVersion
+     * @returns SuiteLicenseFeatureDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsFeatures(
+        tenantId: string,
+        enrollmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseFeatureDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/Features',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param feature
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsHasAccess(
+        tenantId: string,
+        enrollmentId: string,
+        feature?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/HasAccess',
             path: {
                 'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'feature': feature,
+            },
+            errors: {
+                403: `Forbidden`,
             },
         });
     }
     /**
+     * @param xApiVersion
      * @param requestBody
-     * @returns EmptyEnvelope Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2Tenants(
+        xApiVersion?: string,
         requestBody?: TenantCreateDto,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/Tenants',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
@@ -300,15 +812,20 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2Tenants(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
             url: '/api/v2/Tenants',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'tenantId': tenantId,
             },
@@ -322,13 +839,15 @@ export class TenantsService {
      * @param tenantId
      * @param backTo
      * @param enableRedirect
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsSelect(
         tenantId: string,
         backTo?: string,
         enableRedirect: boolean = true,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -336,6 +855,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
@@ -350,13 +872,15 @@ export class TenantsService {
      * @param tenantId
      * @param backTo
      * @param enableRedirect
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2TenantsSelect(
         tenantId: string,
         backTo?: string,
         enableRedirect: boolean = true,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
@@ -364,6 +888,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
@@ -377,16 +904,21 @@ export class TenantsService {
     /**
      * @param backTo
      * @param enableRedirect
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsDeselect(
         backTo?: string,
         enableRedirect: boolean = true,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/Deselect',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
@@ -400,16 +932,21 @@ export class TenantsService {
     /**
      * @param backTo
      * @param enableRedirect
-     * @returns EmptyEnvelope Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2TenantsDeselect(
         backTo?: string,
         enableRedirect: boolean = true,
+        xApiVersion?: string,
     ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/Tenants/Deselect',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
@@ -422,27 +959,13 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsAppAuthorization(
-        tenantId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{tenantId}/AppAuthorization',
-            path: {
-                'tenantId': tenantId,
-            },
-        });
-    }
-    /**
-     * @param tenantId
-     * @returns WebPortalDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns WebPortalDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsWebPortals(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<WebPortalDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -450,6 +973,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,
@@ -458,11 +984,13 @@ export class TenantsService {
     }
     /**
      * @param tenantId
-     * @returns NotificationDtoListEnvelope Success
+     * @param xApiVersion
+     * @returns NotificationDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsNotifications(
         tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<NotificationDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
@@ -470,6 +998,9 @@ export class TenantsService {
             path: {
                 'tenantId': tenantId,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,