@fenixalliance/abs-api-client 1.0.2 → 1.0.3

package/clients/systemService/models/ModuleListEnvelope.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Module } from './Module';
+export type ModuleListEnvelope = {
+    readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
+    readonly timestamp?: string;
+    readonly activityId?: string | null;
+    result?: Array<Module> | null;
+};
+

package/clients/systemService/models/StringListEnvelope.ts

@@ -3,11 +3,11 @@
 /* tslint:disable */
 /* eslint-disable */
 export type StringListEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: Array<string> | null;
 };
 

package/clients/systemService/models/StudioModule.ts

@@ -0,0 +1,9 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type StudioModule = {
+    name?: string | null;
+    version?: string | null;
+};
+

package/clients/{catalogService/models/StockItemDtoListEnvelope.ts → systemService/models/StudioModuleListEnvelope.ts}

@@ -2,13 +2,13 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
-import type { StockItemDto } from './StockItemDto';
-export type StockItemDtoListEnvelope = {
-    errorMessage?: string | null;
+import type { StudioModule } from './StudioModule';
+export type StudioModuleListEnvelope = {
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
-    result?: Array<StockItemDto> | null;
+    result?: Array<StudioModule> | null;
 };
 

package/clients/systemService/models/SuiteLicenseAssignmentDto.ts

@@ -0,0 +1,16 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type SuiteLicenseAssignmentDto = {
+    id?: string | null;
+    timestamp?: string | null;
+    name?: string | null;
+    assigned?: boolean;
+    enrollmentId?: string | null;
+    suiteLicenseId?: string | null;
+    expirationDate?: string;
+    availableSeats?: number;
+    totalSeats?: number;
+};
+

package/clients/systemService/models/SuiteLicenseAssignmentDtoListEnvelope.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { SuiteLicenseAssignmentDto } from './SuiteLicenseAssignmentDto';
+export type SuiteLicenseAssignmentDtoListEnvelope = {
+    readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
+    readonly timestamp?: string;
+    readonly activityId?: string | null;
+    result?: Array<SuiteLicenseAssignmentDto> | null;
+};
+

package/clients/systemService/models/SuiteLicenseDto.ts

@@ -0,0 +1,15 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type SuiteLicenseDto = {
+    id?: string | null;
+    timestamp?: string | null;
+    tenantId?: string | null;
+    licenseString?: string | null;
+    enrollmentId?: string | null;
+    expirationDate?: string;
+    availableSeats?: number;
+    totalSeats?: number;
+};
+

package/clients/systemService/models/SuiteLicenseDtoEnvelope.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { SuiteLicenseDto } from './SuiteLicenseDto';
+export type SuiteLicenseDtoEnvelope = {
+    readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
+    readonly timestamp?: string;
+    readonly activityId?: string | null;
+    result?: SuiteLicenseDto;
+};
+

package/clients/systemService/models/SuiteLicenseDtoListEnvelope.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { SuiteLicenseDto } from './SuiteLicenseDto';
+export type SuiteLicenseDtoListEnvelope = {
+    readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
+    readonly timestamp?: string;
+    readonly activityId?: string | null;
+    result?: Array<SuiteLicenseDto> | null;
+};
+

package/clients/systemService/services/AntiforgeryService.ts

@@ -7,23 +7,35 @@ import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class AntiforgeryService {
     /**
-     * @returns any Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
-    public static getApiV2SystemServiceAntiforgeryGetAndStoreTokens(): CancelablePromise<any> {
+    public static getApiV2SystemServiceAntiforgeryGetAndStoreTokens(
+        xApiVersion?: string,
+    ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/SystemService/Antiforgery/GetAndStoreTokens',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
     /**
-     * @returns any Success
+     * @param xApiVersion
+     * @returns any OK
      * @throws ApiError
      */
-    public static getApiV2SystemServiceAntiforgeryIsRequestValid(): CancelablePromise<any> {
+    public static getApiV2SystemServiceAntiforgeryIsRequestValid(
+        xApiVersion?: string,
+    ): CancelablePromise<any> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/SystemService/Antiforgery/IsRequestValid',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
         });
     }
 }

package/clients/systemService/services/LicensingService.ts

@@ -0,0 +1,230 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BooleanEnvelope } from '../models/BooleanEnvelope';
+import type { GeneralValidationFailureListEnvelope } from '../models/GeneralValidationFailureListEnvelope';
+import type { LicenseValidationRequest } from '../models/LicenseValidationRequest';
+import type { SuiteLicenseAssignmentDtoListEnvelope } from '../models/SuiteLicenseAssignmentDtoListEnvelope';
+import type { SuiteLicenseDtoEnvelope } from '../models/SuiteLicenseDtoEnvelope';
+import type { SuiteLicenseDtoListEnvelope } from '../models/SuiteLicenseDtoListEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class LicensingService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns SuiteLicenseDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SystemServiceLicensingLicenses(
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SystemService/Licensing/Licenses',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param licenseId
+     * @param xApiVersion
+     * @returns SuiteLicenseDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SystemServiceLicensingLicenses1(
+        licenseId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SystemService/Licensing/Licenses/{licenseId}',
+            path: {
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param licenseId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns SuiteLicenseAssignmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SystemServiceLicensingLicensesAssignments(
+        licenseId: string,
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseAssignmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SystemService/Licensing/Licenses/{licenseId}/Assignments',
+            path: {
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param licenseId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns SuiteLicenseAssignmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SystemServiceLicensingLicensesAttributes(
+        licenseId: string,
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseAssignmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SystemService/Licensing/Licenses/{licenseId}/Attributes',
+            path: {
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param licenseId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns SuiteLicenseAssignmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SystemServiceLicensingLicensesFeatures(
+        licenseId: string,
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseAssignmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SystemService/Licensing/Licenses/{licenseId}/Features',
+            path: {
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param licenseId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns SuiteLicenseAssignmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SystemServiceLicensingLicensesQuota(
+        licenseId: string,
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SuiteLicenseAssignmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SystemService/Licensing/Licenses/{licenseId}/Quota',
+            path: {
+                'licenseId': licenseId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns BooleanEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2SystemServiceLicensingLicensesRedeem(
+        tenantId: string,
+        requestBody: LicenseValidationRequest,
+        xApiVersion?: string,
+    ): CancelablePromise<BooleanEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/SystemService/Licensing/Licenses/Redeem',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json;odata.metadata=minimal;odata.streaming=true',
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @param xApiVersion
+     * @returns GeneralValidationFailureListEnvelope OK
+     * @throws ApiError
+     */
+    public static postApiV2SystemServiceLicensingLicensesValidate(
+        requestBody: LicenseValidationRequest,
+        xApiVersion?: string,
+    ): CancelablePromise<GeneralValidationFailureListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/SystemService/Licensing/Licenses/Validate',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json;odata.metadata=minimal;odata.streaming=true',
+            errors: {
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/systemService/services/MigrationsService.ts

@@ -9,15 +9,20 @@ import { request as __request } from '../core/request';
 export class MigrationsService {
     /**
      * @param pending
-     * @returns StringListEnvelope Success
+     * @param xApiVersion
+     * @returns StringListEnvelope OK
      * @throws ApiError
      */
     public static getApiV2SystemServiceMigrations(
         pending?: boolean,
+        xApiVersion?: string,
     ): CancelablePromise<StringListEnvelope> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/v2/SystemService/Migrations',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             query: {
                 'pending': pending,
             },
@@ -28,13 +33,19 @@ export class MigrationsService {
         });
     }
     /**
-     * @returns StringListEnvelope Success
+     * @param xApiVersion
+     * @returns StringListEnvelope OK
      * @throws ApiError
      */
-    public static postApiV2SystemServiceMigrationsMigrate(): CancelablePromise<StringListEnvelope> {
+    public static postApiV2SystemServiceMigrationsMigrate(
+        xApiVersion?: string,
+    ): CancelablePromise<StringListEnvelope> {
         return __request(OpenAPI, {
             method: 'POST',
             url: '/api/v2/SystemService/Migrations/Migrate',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
             errors: {
                 401: `Unauthorized`,
                 403: `Forbidden`,

package/clients/systemService/services/ModulesService.ts

@@ -0,0 +1,61 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ModuleListEnvelope } from '../models/ModuleListEnvelope';
+import type { StudioModuleListEnvelope } from '../models/StudioModuleListEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ModulesService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns StudioModuleListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2StudioServiceModules(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<StudioModuleListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/StudioService/Modules',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns ModuleListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2StudioServiceModulesData(
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<ModuleListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/StudioService/Modules/Data',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/index.ts

@@ -12,22 +12,119 @@ export type { CartDto } from './models/CartDto';
 export type { CartDtoEnvelope } from './models/CartDtoEnvelope';
 export type { EmptyEnvelope } from './models/EmptyEnvelope';
 export type { ErrorEnvelope } from './models/ErrorEnvelope';
+export type { ExtendedTenantDto } from './models/ExtendedTenantDto';
+export type { ExtendedTenantDtoEnvelope } from './models/ExtendedTenantDtoEnvelope';
+export type { ExtendedTenantEnrolmentDto } from './models/ExtendedTenantEnrolmentDto';
+export type { ExtendedTenantEnrolmentDtoEnvelope } from './models/ExtendedTenantEnrolmentDtoEnvelope';
 export type { NotificationDto } from './models/NotificationDto';
 export type { NotificationDtoListEnvelope } from './models/NotificationDtoListEnvelope';
+export { Operation } from './models/Operation';
 export { PlatformUserDto } from './models/PlatformUserDto';
 export type { PlatformUserDtoListEnvelope } from './models/PlatformUserDtoListEnvelope';
 export { SocialProfileDto } from './models/SocialProfileDto';
 export type { SocialProfileDtoEnvelope } from './models/SocialProfileDtoEnvelope';
 export type { StringListEnvelope } from './models/StringListEnvelope';
+export type { SuiteLicenseAssignmentDto } from './models/SuiteLicenseAssignmentDto';
+export type { SuiteLicenseAssignmentDtoListEnvelope } from './models/SuiteLicenseAssignmentDtoListEnvelope';
+export type { SuiteLicenseDto } from './models/SuiteLicenseDto';
+export type { SuiteLicenseDtoListEnvelope } from './models/SuiteLicenseDtoListEnvelope';
+export type { SuiteLicenseFeatureDto } from './models/SuiteLicenseFeatureDto';
+export type { SuiteLicenseFeatureDtoListEnvelope } from './models/SuiteLicenseFeatureDtoListEnvelope';
 export type { TenantCreateDto } from './models/TenantCreateDto';
+export type { TenantDepartmentCreateDto } from './models/TenantDepartmentCreateDto';
+export type { TenantDepartmentDto } from './models/TenantDepartmentDto';
+export type { TenantDepartmentDtoEnvelope } from './models/TenantDepartmentDtoEnvelope';
+export type { TenantDepartmentDtoListEnvelope } from './models/TenantDepartmentDtoListEnvelope';
+export type { TenantDepartmentUpdateDto } from './models/TenantDepartmentUpdateDto';
 export type { TenantDto } from './models/TenantDto';
 export type { TenantDtoEnvelope } from './models/TenantDtoEnvelope';
-export type { TenantEnrollmentDto } from './models/TenantEnrollmentDto';
-export type { TenantEnrollmentDtoEnvelope } from './models/TenantEnrollmentDtoEnvelope';
-export type { TenantEnrollmentDtoListEnvelope } from './models/TenantEnrollmentDtoListEnvelope';
+export type { TenantEnrollmentCreateDto } from './models/TenantEnrollmentCreateDto';
+export type { TenantEnrollmentUpdateDto } from './models/TenantEnrollmentUpdateDto';
+export type { TenantEnrolmentDto } from './models/TenantEnrolmentDto';
+export type { TenantEnrolmentDtoEnvelope } from './models/TenantEnrolmentDtoEnvelope';
+export type { TenantEnrolmentDtoListEnvelope } from './models/TenantEnrolmentDtoListEnvelope';
+export type { TenantIndustryCreateDto } from './models/TenantIndustryCreateDto';
+export type { TenantIndustryDto } from './models/TenantIndustryDto';
+export type { TenantIndustryDtoEnvelope } from './models/TenantIndustryDtoEnvelope';
+export type { TenantIndustryUpdateDto } from './models/TenantIndustryUpdateDto';
+export type { TenantInvitationCreateDto } from './models/TenantInvitationCreateDto';
+export type { TenantInvitationDto } from './models/TenantInvitationDto';
+export type { TenantInvitationDtoEnvelope } from './models/TenantInvitationDtoEnvelope';
+export type { TenantInvitationDtoListEnvelope } from './models/TenantInvitationDtoListEnvelope';
+export type { TenantPositionCreateDto } from './models/TenantPositionCreateDto';
+export type { TenantPositionDto } from './models/TenantPositionDto';
+export type { TenantPositionDtoEnvelope } from './models/TenantPositionDtoEnvelope';
+export type { TenantPositionDtoListEnvelope } from './models/TenantPositionDtoListEnvelope';
+export type { TenantPositionUpdateDto } from './models/TenantPositionUpdateDto';
+export type { TenantSegmentCreateDto } from './models/TenantSegmentCreateDto';
+export type { TenantSegmentDto } from './models/TenantSegmentDto';
+export type { TenantSegmentDtoEnvelope } from './models/TenantSegmentDtoEnvelope';
+export type { TenantSegmentDtoListEnvelope } from './models/TenantSegmentDtoListEnvelope';
+export type { TenantSegmentUpdateDto } from './models/TenantSegmentUpdateDto';
+export type { TenantSizeCreateDto } from './models/TenantSizeCreateDto';
+export type { TenantSizeDto } from './models/TenantSizeDto';
+export type { TenantSizeDtoEnvelope } from './models/TenantSizeDtoEnvelope';
+export type { TenantSizeDtoListEnvelope } from './models/TenantSizeDtoListEnvelope';
+export type { TenantSizeUpdateDto } from './models/TenantSizeUpdateDto';
+export type { TenantTeamContactEnrollmentCreateDto } from './models/TenantTeamContactEnrollmentCreateDto';
+export type { TenantTeamContactEnrollmentDto } from './models/TenantTeamContactEnrollmentDto';
+export type { TenantTeamContactEnrollmentDtoEnvelope } from './models/TenantTeamContactEnrollmentDtoEnvelope';
+export type { TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope } from './models/TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope';
+export type { TenantTeamContactEnrollmentUpdateDto } from './models/TenantTeamContactEnrollmentUpdateDto';
+export type { TenantTeamCreateDto } from './models/TenantTeamCreateDto';
+export type { TenantTeamDto } from './models/TenantTeamDto';
+export type { TenantTeamDtoEnvelope } from './models/TenantTeamDtoEnvelope';
+export type { TenantTeamDtoIReadOnlyCollectionEnvelope } from './models/TenantTeamDtoIReadOnlyCollectionEnvelope';
+export type { TenantTeamEmployeeEnrollmentCreateDto } from './models/TenantTeamEmployeeEnrollmentCreateDto';
+export type { TenantTeamEmployeeEnrollmentDto } from './models/TenantTeamEmployeeEnrollmentDto';
+export type { TenantTeamEmployeeEnrollmentDtoEnvelope } from './models/TenantTeamEmployeeEnrollmentDtoEnvelope';
+export type { TenantTeamEmployeeEnrollmentDtoIReadOnlyCollectionEnvelope } from './models/TenantTeamEmployeeEnrollmentDtoIReadOnlyCollectionEnvelope';
+export type { TenantTeamEmployeeEnrollmentUpdateDto } from './models/TenantTeamEmployeeEnrollmentUpdateDto';
+export type { TenantTeamProjectEnrollmentCreateDto } from './models/TenantTeamProjectEnrollmentCreateDto';
+export type { TenantTeamProjectEnrollmentDto } from './models/TenantTeamProjectEnrollmentDto';
+export type { TenantTeamProjectEnrollmentDtoEnvelope } from './models/TenantTeamProjectEnrollmentDtoEnvelope';
+export type { TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope } from './models/TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope';
+export type { TenantTeamProjectEnrollmentUpdateDto } from './models/TenantTeamProjectEnrollmentUpdateDto';
+export type { TenantTeamRecordCreateDto } from './models/TenantTeamRecordCreateDto';
+export type { TenantTeamRecordDto } from './models/TenantTeamRecordDto';
+export type { TenantTeamRecordDtoEnvelope } from './models/TenantTeamRecordDtoEnvelope';
+export type { TenantTeamRecordDtoIReadOnlyCollectionEnvelope } from './models/TenantTeamRecordDtoIReadOnlyCollectionEnvelope';
+export type { TenantTeamRecordUpdateDto } from './models/TenantTeamRecordUpdateDto';
+export type { TenantTeamUpdateDto } from './models/TenantTeamUpdateDto';
+export type { TenantTerritoryCreateDto } from './models/TenantTerritoryCreateDto';
+export type { TenantTerritoryDto } from './models/TenantTerritoryDto';
+export type { TenantTerritoryDtoEnvelope } from './models/TenantTerritoryDtoEnvelope';
+export type { TenantTerritoryDtoListEnvelope } from './models/TenantTerritoryDtoListEnvelope';
+export type { TenantTerritoryUpdateDto } from './models/TenantTerritoryUpdateDto';
+export type { TenantTypeCreateDto } from './models/TenantTypeCreateDto';
+export type { TenantTypeDto } from './models/TenantTypeDto';
+export type { TenantTypeDtoEnvelope } from './models/TenantTypeDtoEnvelope';
+export type { TenantTypeDtoIReadOnlyCollectionEnvelope } from './models/TenantTypeDtoIReadOnlyCollectionEnvelope';
+export type { TenantTypeUpdateDto } from './models/TenantTypeUpdateDto';
+export type { TenantUnitCreateDto } from './models/TenantUnitCreateDto';
+export type { TenantUnitDto } from './models/TenantUnitDto';
+export type { TenantUnitDtoEnvelope } from './models/TenantUnitDtoEnvelope';
+export type { TenantUnitDtoListEnvelope } from './models/TenantUnitDtoListEnvelope';
+export type { TenantUnitUpdateDto } from './models/TenantUnitUpdateDto';
+export type { TenantUpdateDto } from './models/TenantUpdateDto';
 export type { WalletDto } from './models/WalletDto';
 export type { WalletDtoEnvelope } from './models/WalletDtoEnvelope';
 export type { WebPortalDto } from './models/WebPortalDto';
 export type { WebPortalDtoListEnvelope } from './models/WebPortalDtoListEnvelope';
 
+export { DepartmentsService } from './services/DepartmentsService';
+export { EmployeeEnrollmentsService } from './services/EmployeeEnrollmentsService';
+export { EnrollmentsService } from './services/EnrollmentsService';
+export { IndustriesService } from './services/IndustriesService';
+export { InvitationsService } from './services/InvitationsService';
+export { PositionsService } from './services/PositionsService';
+export { SegmentsService } from './services/SegmentsService';
+export { SizesService } from './services/SizesService';
+export { TeamContactEnrollmentsService } from './services/TeamContactEnrollmentsService';
+export { TeamProjectEnrollmentService } from './services/TeamProjectEnrollmentService';
+export { TeamRecordsService } from './services/TeamRecordsService';
+export { TeamsService } from './services/TeamsService';
 export { TenantsService } from './services/TenantsService';
+export { TerritoriesService } from './services/TerritoriesService';
+export { TypesService } from './services/TypesService';
+export { UnitsService } from './services/UnitsService';

package/clients/tenantService/models/BooleanEnvelope.ts

@@ -3,11 +3,11 @@
 /* tslint:disable */
 /* eslint-disable */
 export type BooleanEnvelope = {
-    errorMessage?: string | null;
     readonly isSuccess?: boolean;
+    errorMessage?: string | null;
+    correlationId?: string | null;
     readonly timestamp?: string;
     readonly activityId?: string | null;
-    correlationId?: string | null;
     result?: boolean;
 };