@fenixalliance/abs-api-client 1.0.1 → 1.0.3

package/clients/tenantService/services/TenantsService.ts

@@ -2,352 +2,1008 @@
 /* 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 { 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 { WalletDtoTaskEnvelope } from '../models/WalletDtoTaskEnvelope';
+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 { 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';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class TenantsService {
     /**
-     * @returns BusinessDto Success
+     * @param xApiVersion
+     * @returns TenantDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2TenantsCurrent(): CancelablePromise<BusinessDto> {
+    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`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantDtoEnvelope OK
+     * @throws ApiError
+     */
+    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`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns BusinessDto Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2Tenants(
-        businessId: string,
-    ): CancelablePromise<BusinessDto> {
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @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/{businessId}',
+            url: '/api/v2/Tenants/{tenantId}/Avatar',
             path: {
-                'businessId': businessId,
+                '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 businessId
-     * @returns WalletDtoTaskEnvelope Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns WalletDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsWallet(
-        businessId: string,
-    ): CancelablePromise<WalletDtoTaskEnvelope> {
+        tenantId: string,
+        xApiVersion?: 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,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns SocialProfileDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsSocialProfile(
-        businessId: string,
-    ): CancelablePromise<any> {
+        tenantId: string,
+        xApiVersion?: 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,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns CartDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsCart(
-        businessId: string,
-    ): CancelablePromise<any> {
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<CartDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Cart',
+            path: {
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns PlatformUserDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsUsers(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<PlatformUserDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Cart',
+            url: '/api/v2/Tenants/{tenantId}/Users',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns BusinessEnrollmentDtoIReadOnlyListEnvelope Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantEnrolmentDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollments(
-        businessId: string,
-    ): CancelablePromise<BusinessEnrollmentDtoIReadOnlyListEnvelope> {
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantEnrolmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param enrollmentId
-     * @returns BusinessEnrollmentDtoEnvelope Success
+     * @param xApiVersion
+     * @returns TenantEnrolmentDtoEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollments1(
-        businessId: string,
+        tenantId: string,
         enrollmentId: string,
-    ): CancelablePromise<BusinessEnrollmentDtoEnvelope> {
+        xApiVersion?: string,
+    ): CancelablePromise<TenantEnrolmentDtoEnvelope> {
         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,
             },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param enrollmentId
-     * @returns any Success
+     * @param xApiVersion
+     * @returns ExtendedTenantEnrolmentDtoEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2TenantsEnrollmentsLicenses(
-        businessId: string,
+    public static getApiV2TenantsEnrollmentsExtended(
+        tenantId: string,
         enrollmentId: string,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<ExtendedTenantEnrolmentDtoEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Licenses',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/Extended',
             path: {
-                'businessId': businessId,
-                'enrollmentID': enrollmentId,
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param enrollmentId
-     * @returns StringListEnvelope Success
+     * @param xApiVersion
+     * @returns StringListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsEnrollmentsPermissions(
-        businessId: string,
+        tenantId: string,
         enrollmentId: string,
+        xApiVersion?: string,
     ): CancelablePromise<StringListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Permissions',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/Permissions',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param roles
+     * @param permissions
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsPermissionsValidate(
+        tenantId: string,
+        enrollmentId: string,
+        roles?: Array<string>,
+        permissions?: Array<string>,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentID}/Permissions/Validate',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'roles': roles,
+                'permissions': permissions,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @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: {
-                'businessId': businessId,
-                'enrollmentID': enrollmentId,
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @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(
-        businessId: string,
-    ): CancelablePromise<any> {
+        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
+     * @param xApiVersion
+     * @returns SuiteLicenseAssignmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsLicenses(
+        tenantId: string,
+        enrollmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseAssignmentDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Licenses',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            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 getApiV2TenantsEnrollmentsLicenses1(
+        tenantId: string,
+        enrollmentId: string,
+        licenseId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            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: {
-                'businessId': businessId,
+                '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 any Success
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2Tenants(
-        requestBody?: BusinessCreateDto,
-    ): CancelablePromise<any> {
+        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: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static deleteApiV2Tenants(
-        businessId: string,
-    ): CancelablePromise<any> {
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'DELETE',
             url: '/api/v2/Tenants',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsSelect(
-        businessId: string,
+        tenantId: string,
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Select',
+            url: '/api/v2/Tenants/{tenantId}/Select',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
+     * @param tenantId
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2TenantsSelect(
-        businessId: string,
+        tenantId: string,
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/v2/Tenants/{businessId}/Select',
+            url: '/api/v2/Tenants/{tenantId}/Select',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
             },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsDeselect(
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/Tenants/Deselect',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
      * @param backTo
      * @param enableRedirect
-     * @returns any Success
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
      * @throws ApiError
      */
     public static postApiV2TenantsDeselect(
         backTo?: string,
         enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/Tenants/Deselect',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'backTo': backTo,
                 'enableRedirect': enableRedirect,
             },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
         });
     }
     /**
-     * @param businessId
-     * @returns any Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns WebPortalDtoListEnvelope OK
      * @throws ApiError
      */
-    public static getApiV2TenantsAppAuthorization(
-        businessId: string,
-    ): CancelablePromise<any> {
+    public static getApiV2TenantsWebPortals(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<WebPortalDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/AppAuthorization',
+            url: '/api/v2/Tenants/{tenantId}/WebPortals',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }
     /**
-     * @param businessId
-     * @returns NotificationDtoListEnvelope Success
+     * @param tenantId
+     * @param xApiVersion
+     * @returns NotificationDtoListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2TenantsNotifications(
-        businessId: string,
+        tenantId: string,
+        xApiVersion?: string,
     ): CancelablePromise<NotificationDtoListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Notifications',
+            url: '/api/v2/Tenants/{tenantId}/Notifications',
             path: {
-                'businessId': businessId,
+                'tenantId': tenantId,
             },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns BusinessEnrollmentDto Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsUserEnrollments(
-        businessId: string,
-    ): CancelablePromise<Array<BusinessEnrollmentDto>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/UserEnrollments',
-            path: {
-                'businessId': businessId,
+            headers: {
+                'x-api-version': xApiVersion,
             },
             errors: {
                 401: `Unauthorized`,
+                403: `Forbidden`,
             },
         });
     }