@fenixalliance/abs-api-client 1.0.1 → 2.0.0

package/clients/tenantService/services/SizesService.ts

@@ -0,0 +1,168 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancellationToken } from '../models/CancellationToken';
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Operation } from '../models/Operation';
+import type { TenantSizeCreateDto } from '../models/TenantSizeCreateDto';
+import type { TenantSizeDtoEnvelope } from '../models/TenantSizeDtoEnvelope';
+import type { TenantSizeDtoIReadOnlyListEnvelope } from '../models/TenantSizeDtoIReadOnlyListEnvelope';
+import type { TenantSizeUpdateDto } from '../models/TenantSizeUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class SizesService {
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns TenantSizeDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2Sizes(
+        tenantId: string,
+        requestBody?: TenantSizeCreateDto,
+    ): CancelablePromise<TenantSizeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Sizes',
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantSizeId
+     * @param cancellationToken
+     * @returns TenantSizeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Sizes(
+        tenantSizeId: string,
+        cancellationToken?: CancellationToken,
+    ): CancelablePromise<TenantSizeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            query: {
+                'cancellationToken': cancellationToken,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantSizeId
+     * @param requestBody
+     * @returns TenantSizeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Sizes(
+        tenantId: string,
+        tenantSizeId: string,
+        requestBody?: TenantSizeUpdateDto,
+    ): CancelablePromise<TenantSizeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantSizeId
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Sizes(
+        tenantId: string,
+        tenantSizeId: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantSizeId
+     * @returns TenantSizeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2Sizes(
+        tenantId: string,
+        tenantSizeId: string,
+    ): CancelablePromise<TenantSizeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantSizeDtoIReadOnlyListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SizesList(
+        tenantId: string,
+    ): CancelablePromise<TenantSizeDtoIReadOnlyListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Sizes/List',
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/services/TeamContactEnrollmentsService.ts

@@ -0,0 +1,161 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Operation } from '../models/Operation';
+import type { TenantTeamContactEnrollmentCreateDto } from '../models/TenantTeamContactEnrollmentCreateDto';
+import type { TenantTeamContactEnrollmentDtoEnvelope } from '../models/TenantTeamContactEnrollmentDtoEnvelope';
+import type { TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope } from '../models/TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope';
+import type { TenantTeamContactEnrollmentUpdateDto } from '../models/TenantTeamContactEnrollmentUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class TeamContactEnrollmentsService {
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns TenantTeamContactEnrollmentDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2TeamContactEnrollments(
+        tenantId: string,
+        requestBody?: TenantTeamContactEnrollmentCreateDto,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/TeamContactEnrollments',
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamContactEnrollmentId
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamContactEnrollments(
+        tenantTeamContactEnrollmentId: string,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamContactEnrollmentId
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2TeamContactEnrollments(
+        tenantId: string,
+        tenantTeamContactEnrollmentId: string,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamContactEnrollmentId
+     * @param requestBody
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2TeamContactEnrollments(
+        tenantId: string,
+        tenantTeamContactEnrollmentId: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamContactEnrollmentId
+     * @param requestBody
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2TeamContactEnrollments(
+        tenantId: string,
+        tenantTeamContactEnrollmentId: string,
+        requestBody?: TenantTeamContactEnrollmentUpdateDto,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamContactEnrollmentsList(
+        tenantId: string,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamContactEnrollments/List',
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/services/TeamProjectEnrollmentService.ts

@@ -0,0 +1,151 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Operation } from '../models/Operation';
+import type { TenantTeamProjectEnrollmentCreateDto } from '../models/TenantTeamProjectEnrollmentCreateDto';
+import type { TenantTeamProjectEnrollmentDtoEnvelope } from '../models/TenantTeamProjectEnrollmentDtoEnvelope';
+import type { TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope } from '../models/TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope';
+import type { TenantTeamProjectEnrollmentUpdateDto } from '../models/TenantTeamProjectEnrollmentUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class TeamProjectEnrollmentService {
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2TeamProjectEnrollment(
+        tenantId: string,
+        requestBody?: TenantTeamProjectEnrollmentCreateDto,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/TeamProjectEnrollment',
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamId
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamProjectEnrollment(
+        tenantTeamId: string,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamId
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2TeamProjectEnrollment(
+        tenantId: string,
+        tenantTeamId: string,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamId
+     * @param requestBody
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2TeamProjectEnrollment(
+        tenantTeamId: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamId
+     * @param requestBody
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2TeamProjectEnrollment(
+        tenantTeamId: string,
+        requestBody?: TenantTeamProjectEnrollmentUpdateDto,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamProjectEnrollmentList(
+        tenantId: string,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamProjectEnrollment/List',
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/services/TeamRecordsService.ts

@@ -0,0 +1,162 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Operation } from '../models/Operation';
+import type { TenantTeamRecordCreateDto } from '../models/TenantTeamRecordCreateDto';
+import type { TenantTeamRecordDtoEnvelope } from '../models/TenantTeamRecordDtoEnvelope';
+import type { TenantTeamRecordDtoIReadOnlyCollectionEnvelope } from '../models/TenantTeamRecordDtoIReadOnlyCollectionEnvelope';
+import type { TenantTeamRecordUpdateDto } from '../models/TenantTeamRecordUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class TeamRecordsService {
+    /**
+     * @param tenantId
+     * @param requestBody
+     * @returns TenantTeamRecordDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2TeamRecords(
+        tenantId: string,
+        requestBody?: TenantTeamRecordCreateDto,
+    ): CancelablePromise<TenantTeamRecordDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/TeamRecords',
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamId
+     * @returns TenantTeamRecordDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamRecords(
+        tenantTeamId: string,
+    ): CancelablePromise<TenantTeamRecordDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamRecords/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamId
+     * @returns TenantTeamRecordDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2TeamRecords(
+        tenantId: string,
+        tenantTeamId: string,
+    ): CancelablePromise<TenantTeamRecordDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/TeamRecords/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamId
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2TeamRecords(
+        tenantId: string,
+        tenantTeamId: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/TeamRecords/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamId
+     * @param requestBody
+     * @returns TenantTeamRecordDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2TeamRecords(
+        tenantId: string,
+        tenantTeamId: string,
+        requestBody?: TenantTeamRecordUpdateDto,
+    ): CancelablePromise<TenantTeamRecordDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/TeamRecords/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @returns TenantTeamRecordDtoIReadOnlyCollectionEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamRecordsList(
+        tenantId: string,
+    ): CancelablePromise<TenantTeamRecordDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamRecords/List',
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}