@fenixalliance/abs-api-client 1.0.2 → 1.0.3

package/clients/tenantService/services/SizesService.ts

@@ -0,0 +1,194 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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 { TenantSizeDtoListEnvelope } from '../models/TenantSizeDtoListEnvelope';
+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 {
+    /**
+     * Creates a new tenant size
+     * Creates a new tenant size and returns an empty envelope.
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static createTenantSizeAsync(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: TenantSizeCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/Sizes',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantSizeDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Sizes(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantSizeDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Sizes',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantSizeId
+     * @param xApiVersion
+     * @returns TenantSizeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2Sizes1(
+        tenantSizeId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantSizeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantSizeId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantSizeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2Sizes(
+        tenantId: string,
+        tenantSizeId: string,
+        xApiVersion?: string,
+        requestBody?: TenantSizeUpdateDto,
+    ): CancelablePromise<TenantSizeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantSizeId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2Sizes(
+        tenantId: string,
+        tenantSizeId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantSizeId
+     * @param xApiVersion
+     * @returns TenantSizeDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2Sizes(
+        tenantId: string,
+        tenantSizeId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantSizeDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/Sizes/{tenantSizeId}',
+            path: {
+                'tenantSizeId': tenantSizeId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/services/TeamContactEnrollmentsService.ts

@@ -0,0 +1,191 @@
+/* generated using openapi-typescript-codegen -- do no 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 xApiVersion
+     * @param requestBody
+     * @returns TenantTeamContactEnrollmentDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2TeamContactEnrollments(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTeamContactEnrollmentCreateDto,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/TeamContactEnrollments',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamContactEnrollments(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamContactEnrollments',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamContactEnrollmentId
+     * @param xApiVersion
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamContactEnrollments1(
+        tenantTeamContactEnrollmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamContactEnrollmentId
+     * @param xApiVersion
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2TeamContactEnrollments(
+        tenantId: string,
+        tenantTeamContactEnrollmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamContactEnrollmentId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2TeamContactEnrollments(
+        tenantId: string,
+        tenantTeamContactEnrollmentId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamContactEnrollmentId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantTeamContactEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2TeamContactEnrollments(
+        tenantId: string,
+        tenantTeamContactEnrollmentId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTeamContactEnrollmentUpdateDto,
+    ): CancelablePromise<TenantTeamContactEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/TeamContactEnrollments/{tenantTeamContactEnrollmentId}',
+            path: {
+                'tenantTeamContactEnrollmentId': tenantTeamContactEnrollmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/tenantService/services/TeamProjectEnrollmentService.ts

@@ -0,0 +1,181 @@
+/* generated using openapi-typescript-codegen -- do no 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 xApiVersion
+     * @param requestBody
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2TeamProjectEnrollment(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTeamProjectEnrollmentCreateDto,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/TeamProjectEnrollment',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamProjectEnrollment(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoIReadOnlyCollectionEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamProjectEnrollment',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamId
+     * @param xApiVersion
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2TeamProjectEnrollment1(
+        tenantTeamId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param tenantTeamId
+     * @param xApiVersion
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2TeamProjectEnrollment(
+        tenantId: string,
+        tenantTeamId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2TeamProjectEnrollment(
+        tenantTeamId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantTeamId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns TenantTeamProjectEnrollmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2TeamProjectEnrollment(
+        tenantTeamId: string,
+        xApiVersion?: string,
+        requestBody?: TenantTeamProjectEnrollmentUpdateDto,
+    ): CancelablePromise<TenantTeamProjectEnrollmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/TeamProjectEnrollment/{tenantTeamId}',
+            path: {
+                'tenantTeamId': tenantTeamId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}