@fenixalliance/abs-api-client 1.0.1 → 2.0.0

package/clients/tenantService/services/TenantsService.ts

@@ -1,354 +1,805 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* 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 { NotificationDtoListEnvelope } from '../models/NotificationDtoListEnvelope';
-import type { StringListEnvelope } from '../models/StringListEnvelope';
-import type { WalletDtoTaskEnvelope } from '../models/WalletDtoTaskEnvelope';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class TenantsService {
-    /**
-     * @returns BusinessDto Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsCurrent(): CancelablePromise<BusinessDto> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/Current',
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns BusinessDto Success
-     * @throws ApiError
-     */
-    public static getApiV2Tenants(
-        businessId: string,
-    ): CancelablePromise<BusinessDto> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}',
-            path: {
-                'businessId': businessId,
-            },
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns WalletDtoTaskEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsWallet(
-        businessId: string,
-    ): CancelablePromise<WalletDtoTaskEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Wallet',
-            path: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsSocialProfile(
-        businessId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/SocialProfile',
-            path: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsCart(
-        businessId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Cart',
-            path: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns BusinessEnrollmentDtoIReadOnlyListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsEnrollments(
-        businessId: string,
-    ): CancelablePromise<BusinessEnrollmentDtoIReadOnlyListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments',
-            path: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @param enrollmentId
-     * @returns BusinessEnrollmentDtoEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsEnrollments1(
-        businessId: string,
-        enrollmentId: string,
-    ): CancelablePromise<BusinessEnrollmentDtoEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{enrollmentId}',
-            path: {
-                'businessId': businessId,
-                'enrollmentId': enrollmentId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @param enrollmentId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsEnrollmentsLicenses(
-        businessId: string,
-        enrollmentId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Licenses',
-            path: {
-                'businessId': businessId,
-                'enrollmentID': enrollmentId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @param enrollmentId
-     * @returns StringListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsEnrollmentsPermissions(
-        businessId: string,
-        enrollmentId: string,
-    ): CancelablePromise<StringListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Enrollments/{EnrollmentID}/Permissions',
-            path: {
-                'businessId': businessId,
-                'enrollmentID': enrollmentId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsLicenses(
-        businessId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Licenses',
-            path: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @param requestBody
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static postApiV2Tenants(
-        requestBody?: BusinessCreateDto,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/Tenants',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * @param businessId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static deleteApiV2Tenants(
-        businessId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/api/v2/Tenants',
-            query: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @param backTo
-     * @param enableRedirect
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsSelect(
-        businessId: string,
-        backTo?: string,
-        enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Select',
-            path: {
-                'businessId': businessId,
-            },
-            query: {
-                'backTo': backTo,
-                'enableRedirect': enableRedirect,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @param backTo
-     * @param enableRedirect
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static postApiV2TenantsSelect(
-        businessId: string,
-        backTo?: string,
-        enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/Tenants/{businessId}/Select',
-            path: {
-                'businessId': businessId,
-            },
-            query: {
-                'backTo': backTo,
-                'enableRedirect': enableRedirect,
-            },
-        });
-    }
-    /**
-     * @param backTo
-     * @param enableRedirect
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsDeselect(
-        backTo?: string,
-        enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/Deselect',
-            query: {
-                'backTo': backTo,
-                'enableRedirect': enableRedirect,
-            },
-        });
-    }
-    /**
-     * @param backTo
-     * @param enableRedirect
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static postApiV2TenantsDeselect(
-        backTo?: string,
-        enableRedirect: boolean = true,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/v2/Tenants/Deselect',
-            query: {
-                'backTo': backTo,
-                'enableRedirect': enableRedirect,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns any Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsAppAuthorization(
-        businessId: string,
-    ): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/AppAuthorization',
-            path: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @param businessId
-     * @returns NotificationDtoListEnvelope Success
-     * @throws ApiError
-     */
-    public static getApiV2TenantsNotifications(
-        businessId: string,
-    ): CancelablePromise<NotificationDtoListEnvelope> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/v2/Tenants/{businessId}/Notifications',
-            path: {
-                'businessId': businessId,
-            },
-        });
-    }
-    /**
-     * @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,
-            },
-            errors: {
-                401: `Unauthorized`,
-            },
-        });
-    }
-}
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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 { 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 { 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 TenantDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsRoot(): CancelablePromise<TenantDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/Root',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsCurrent(
+        tenantId: string,
+    ): CancelablePromise<TenantDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/Current',
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Tenants(
+        tenantId: string,
+    ): CancelablePromise<TenantDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Tenants(
+        tenantId: string,
+        requestBody?: TenantUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Tenants/{tenantId}',
+            path: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Tenants(
+        tenantId: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Tenants/{tenantId}',
+            path: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns ExtendedTenantDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsExtended(
+        tenantId: string,
+    ): CancelablePromise<ExtendedTenantDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Extended',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsAvatar(
+        tenantId: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Avatar',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param formData
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2TenantsAvatar(
+        tenantId: string,
+        formData?: {
+            avatar?: Blob;
+        },
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/{tenantId}/Avatar',
+            path: {
+                'tenantId': tenantId,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns WalletDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsWallet(
+        tenantId: string,
+    ): CancelablePromise<WalletDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Wallet',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns SocialProfileDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsSocialProfile(
+        tenantId: string,
+    ): CancelablePromise<SocialProfileDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/SocialProfile',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns CartDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsCart(
+        tenantId: string,
+    ): CancelablePromise<CartDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Cart',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns PlatformUserDtoListEnvelope OK
+     * @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 TenantEnrolmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollments(
+        tenantId: string,
+    ): CancelablePromise<TenantEnrolmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @returns TenantEnrolmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollments1(
+        tenantId: string,
+        enrollmentId: string,
+    ): CancelablePromise<TenantEnrolmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @returns StringListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsPermissions(
+        tenantId: string,
+        enrollmentId: string,
+    ): CancelablePromise<StringListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/Permissions',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param roles
+     * @param permissions
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsPermissionsValidate(
+        tenantId: string,
+        enrollmentId: string,
+        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
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitations(
+        tenantId: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitationsPending(
+        tenantId: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations/Pending',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitationsRedeemed(
+        tenantId: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations/Redeemed',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantInvitationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsInvitationsRevoked(
+        tenantId: string,
+    ): CancelablePromise<TenantInvitationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Invitations/Revoked',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsLicenses(
+        tenantId: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Licenses',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @returns SuiteLicenseAssignmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsLicenses(
+        tenantId: string,
+        enrollmentId: string,
+    ): CancelablePromise<SuiteLicenseAssignmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param licenseId
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsLicenses1(
+        tenantId: string,
+        enrollmentId: string,
+        licenseId: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses/{licenseId}',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+                'licenseId': licenseId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param licenseId
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2TenantsEnrollmentsLicenses(
+        tenantId: string,
+        enrollmentId: string,
+        licenseId: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses/{licenseId}',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+                'licenseId': licenseId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param licenseId
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2TenantsEnrollmentsLicenses(
+        tenantId: string,
+        enrollmentId: string,
+        licenseId: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{EnrollmentId}/Licenses/{licenseId}',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+                'licenseId': licenseId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @returns SuiteLicenseFeatureDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsFeatures(
+        tenantId: string,
+        enrollmentId: string,
+    ): CancelablePromise<SuiteLicenseFeatureDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/Features',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param enrollmentId
+     * @param feature
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsEnrollmentsHasAccess(
+        tenantId: string,
+        enrollmentId: string,
+        feature?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Enrollments/{enrollmentId}/HasAccess',
+            path: {
+                'tenantId': tenantId,
+                'enrollmentId': enrollmentId,
+            },
+            query: {
+                'feature': feature,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2Tenants(
+        requestBody?: TenantCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2Tenants(
+        tenantId: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Tenants',
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param backTo
+     * @param enableRedirect
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsSelect(
+        tenantId: string,
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Select',
+            path: {
+                'tenantId': tenantId,
+            },
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param backTo
+     * @param enableRedirect
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2TenantsSelect(
+        tenantId: string,
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/{tenantId}/Select',
+            path: {
+                'tenantId': tenantId,
+            },
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param backTo
+     * @param enableRedirect
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsDeselect(
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/Deselect',
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param backTo
+     * @param enableRedirect
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2TenantsDeselect(
+        backTo?: string,
+        enableRedirect: boolean = true,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Tenants/Deselect',
+            query: {
+                'backTo': backTo,
+                'enableRedirect': enableRedirect,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns WebPortalDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsWebPortals(
+        tenantId: string,
+    ): CancelablePromise<WebPortalDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/WebPortals',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns NotificationDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TenantsNotifications(
+        tenantId: string,
+    ): CancelablePromise<NotificationDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Tenants/{tenantId}/Notifications',
+            path: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}