@fenixalliance/abs-api-client 1.0.2 → 1.0.5

package/clients/supportService/services/SupportRequestAttachmentsService.ts

@@ -0,0 +1,163 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { SupportRequestAttachmentCreateDto } from '../models/SupportRequestAttachmentCreateDto';
+import type { SupportRequestAttachmentDtoEnvelope } from '../models/SupportRequestAttachmentDtoEnvelope';
+import type { SupportRequestAttachmentDtoListEnvelope } from '../models/SupportRequestAttachmentDtoListEnvelope';
+import type { SupportRequestAttachmentUpdateDto } from '../models/SupportRequestAttachmentUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class SupportRequestAttachmentsService {
+    /**
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns SupportRequestAttachmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportRequestAttachments(
+        tenantId?: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportRequestAttachmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportRequestAttachments',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2SupportServiceSupportRequestAttachments(
+        requestBody: SupportRequestAttachmentCreateDto,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/SupportService/SupportRequestAttachments',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestAttachmentId
+     * @param xApiVersion
+     * @returns SupportRequestAttachmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportRequestAttachments1(
+        supportRequestAttachmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportRequestAttachmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportRequestAttachments/{supportRequestAttachmentId}',
+            path: {
+                'supportRequestAttachmentId': supportRequestAttachmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestAttachmentId
+     * @param requestBody
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2SupportServiceSupportRequestAttachments(
+        supportRequestAttachmentId: string,
+        requestBody: SupportRequestAttachmentUpdateDto,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/SupportService/SupportRequestAttachments/{supportRequestAttachmentId}',
+            path: {
+                'supportRequestAttachmentId': supportRequestAttachmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestAttachmentId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2SupportServiceSupportRequestAttachments(
+        supportRequestAttachmentId: string,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/SupportService/SupportRequestAttachments/{supportRequestAttachmentId}',
+            path: {
+                'supportRequestAttachmentId': supportRequestAttachmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/supportService/services/SupportRequestsService.ts

@@ -0,0 +1,290 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { SupportRequestAttachmentCreateDto } from '../models/SupportRequestAttachmentCreateDto';
+import type { SupportRequestAttachmentDtoEnvelope } from '../models/SupportRequestAttachmentDtoEnvelope';
+import type { SupportRequestAttachmentDtoListEnvelope } from '../models/SupportRequestAttachmentDtoListEnvelope';
+import type { SupportRequestCreateDto } from '../models/SupportRequestCreateDto';
+import type { SupportRequestDtoEnvelope } from '../models/SupportRequestDtoEnvelope';
+import type { SupportRequestDtoListEnvelope } from '../models/SupportRequestDtoListEnvelope';
+import type { SupportRequestUpdateDto } from '../models/SupportRequestUpdateDto';
+import type { SupportTicketDtoListEnvelope } from '../models/SupportTicketDtoListEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class SupportRequestsService {
+    /**
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns SupportRequestDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportRequests(
+        tenantId?: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportRequestDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportRequests',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2SupportServiceSupportRequests(
+        requestBody: SupportRequestCreateDto,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/SupportService/SupportRequests',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestId
+     * @param xApiVersion
+     * @returns SupportRequestDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportRequests1(
+        supportRequestId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportRequestDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportRequests/{supportRequestId}',
+            path: {
+                'supportRequestId': supportRequestId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestId
+     * @param requestBody
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2SupportServiceSupportRequests(
+        supportRequestId: string,
+        requestBody: SupportRequestUpdateDto,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/SupportService/SupportRequests/{supportRequestId}',
+            path: {
+                'supportRequestId': supportRequestId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2SupportServiceSupportRequests(
+        supportRequestId: string,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/SupportService/SupportRequests/{supportRequestId}',
+            path: {
+                'supportRequestId': supportRequestId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns SupportTicketDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportRequestsTickets(
+        supportRequestId: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportTicketDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportRequests/{supportRequestId}/Tickets',
+            path: {
+                'supportRequestId': supportRequestId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestId
+     * @param requestBody
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2SupportServiceSupportRequestsAttachments(
+        supportRequestId: string,
+        requestBody: SupportRequestAttachmentCreateDto,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/SupportService/SupportRequests/{supportRequestId}/Attachments',
+            path: {
+                'supportRequestId': supportRequestId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns SupportRequestAttachmentDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportRequestsAttachments(
+        supportRequestId: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportRequestAttachmentDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportRequests/{supportRequestId}/Attachments',
+            path: {
+                'supportRequestId': supportRequestId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportRequestId
+     * @param attachmentId
+     * @param xApiVersion
+     * @returns SupportRequestAttachmentDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportRequestsAttachments1(
+        supportRequestId: string,
+        attachmentId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportRequestAttachmentDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportRequests/{supportRequestId}/Attachments/{attachmentId}',
+            path: {
+                'supportRequestId': supportRequestId,
+                'attachmentId': attachmentId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/supportService/services/SupportTicketPrioritiesService.ts

@@ -0,0 +1,163 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { SupportTicketPriorityCreateDto } from '../models/SupportTicketPriorityCreateDto';
+import type { SupportTicketPriorityDtoEnvelope } from '../models/SupportTicketPriorityDtoEnvelope';
+import type { SupportTicketPriorityDtoListEnvelope } from '../models/SupportTicketPriorityDtoListEnvelope';
+import type { SupportTicketPriorityUpdateDto } from '../models/SupportTicketPriorityUpdateDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class SupportTicketPrioritiesService {
+    /**
+     * @param tenantId
+     * @param pageNumber
+     * @param pageSize
+     * @param xApiVersion
+     * @returns SupportTicketPriorityDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportTicketPriorities(
+        tenantId?: string,
+        pageNumber?: number,
+        pageSize?: number,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportTicketPriorityDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportTicketPriorities',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'pageNumber': pageNumber,
+                'pageSize': pageSize,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param requestBody
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2SupportServiceSupportTicketPriorities(
+        requestBody: SupportTicketPriorityCreateDto,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/SupportService/SupportTicketPriorities',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportTicketPriorityId
+     * @param xApiVersion
+     * @returns SupportTicketPriorityDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2SupportServiceSupportTicketPriorities1(
+        supportTicketPriorityId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<SupportTicketPriorityDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/SupportService/SupportTicketPriorities/{supportTicketPriorityId}',
+            path: {
+                'supportTicketPriorityId': supportTicketPriorityId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportTicketPriorityId
+     * @param requestBody
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2SupportServiceSupportTicketPriorities(
+        supportTicketPriorityId: string,
+        requestBody: SupportTicketPriorityUpdateDto,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/SupportService/SupportTicketPriorities/{supportTicketPriorityId}',
+            path: {
+                'supportTicketPriorityId': supportTicketPriorityId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param supportTicketPriorityId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2SupportServiceSupportTicketPriorities(
+        supportTicketPriorityId: string,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/SupportService/SupportTicketPriorities/{supportTicketPriorityId}',
+            path: {
+                'supportTicketPriorityId': supportTicketPriorityId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}