@fenixalliance/abs-api-client 1.0.3 → 1.0.6

package/clients/contentService/services/BlogPostAuthorsService.ts

@@ -0,0 +1,116 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BlogPostDtoListEnvelope } from '../models/BlogPostDtoListEnvelope';
+import type { Int32Envelope } from '../models/Int32Envelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class BlogPostAuthorsService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns BlogPostDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostAuthors(
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BlogPostDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostAuthors',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param authorId
+     * @param tenantId
+     * @param xApiVersion
+     * @returns BlogPostDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostAuthors1(
+        authorId: string,
+        tenantId?: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BlogPostDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostAuthors/{authorId}',
+            path: {
+                'authorId': authorId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param authorId
+     * @param xApiVersion
+     * @returns BlogPostDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostAuthorsBlogPosts(
+        authorId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BlogPostDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostAuthors/{authorId}/BlogPosts',
+            path: {
+                'authorId': authorId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param authorId
+     * @param xApiVersion
+     * @returns Int32Envelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostAuthorsBlogPostsCount(
+        authorId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Int32Envelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostAuthors/{authorId}/BlogPosts/Count',
+            path: {
+                'authorId': authorId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/contentService/services/BlogPostCategoriesService.ts

@@ -0,0 +1,199 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BlogPostCategoryCreateDto } from '../models/BlogPostCategoryCreateDto';
+import type { BlogPostCategoryDtoEnvelope } from '../models/BlogPostCategoryDtoEnvelope';
+import type { BlogPostCategoryUpdateDto } from '../models/BlogPostCategoryUpdateDto';
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { Operation } from '../models/Operation';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class BlogPostCategoriesService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns BlogPostCategoryDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostCategories(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BlogPostCategoryDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostCategories/{tenantId}',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2ContentServiceBlogPostCategories(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: BlogPostCategoryCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/ContentService/BlogPostCategories/{tenantId}',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param blogPostCategoryId
+     * @param xApiVersion
+     * @returns BlogPostCategoryDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostCategories1(
+        tenantId: string,
+        blogPostCategoryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<Array<BlogPostCategoryDtoEnvelope>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostCategories/{tenantId}/{blogPostCategoryId}',
+            path: {
+                'blogPostCategoryId': blogPostCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param blogPostId
+     * @param blogPostCategoryId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2ContentServiceBlogPostCategories(
+        tenantId: string,
+        blogPostId: string,
+        blogPostCategoryId: string,
+        xApiVersion?: string,
+        requestBody?: Array<Operation>,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/ContentService/BlogPostCategories/{tenantId}/{blogPostCategoryId}',
+            path: {
+                'blogPostCategoryId': blogPostCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+                'blogPostId': blogPostId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param blogPostCategoryId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2ContentServiceBlogPostCategories(
+        tenantId: string,
+        blogPostCategoryId: string,
+        xApiVersion?: string,
+        requestBody?: BlogPostCategoryUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/ContentService/BlogPostCategories/{tenantId}/{blogPostCategoryId}',
+            path: {
+                'blogPostCategoryId': blogPostCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param blogPostCategoryId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2ContentServiceBlogPostCategories(
+        tenantId: string,
+        blogPostCategoryId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/ContentService/BlogPostCategories/{tenantId}/{blogPostCategoryId}',
+            path: {
+                'blogPostCategoryId': blogPostCategoryId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/clients/contentService/services/BlogPostTagsService.ts

@@ -0,0 +1,191 @@
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BlogPostTagCreateDto } from '../models/BlogPostTagCreateDto';
+import type { BlogPostTagDtoEnvelope } from '../models/BlogPostTagDtoEnvelope';
+import type { BlogPostTagDtoListEnvelope } from '../models/BlogPostTagDtoListEnvelope';
+import type { BlogPostTagUpdateDto } from '../models/BlogPostTagUpdateDto';
+import type { EmptyEnvelope } from '../models/EmptyEnvelope';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class BlogPostTagsService {
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @returns BlogPostTagDtoListEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostTags(
+        tenantId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BlogPostTagDtoListEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostTags',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope Created
+     * @throws ApiError
+     */
+    public static postApiV2ContentServiceBlogPostTags(
+        tenantId: string,
+        xApiVersion?: string,
+        requestBody?: BlogPostTagCreateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/v2/ContentService/BlogPostTags',
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param blogPostTagId
+     * @param xApiVersion
+     * @returns BlogPostTagDtoEnvelope OK
+     * @throws ApiError
+     */
+    public static getApiV2ContentServiceBlogPostTags1(
+        blogPostTagId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<BlogPostTagDtoEnvelope> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/v2/ContentService/BlogPostTags/{blogPostTagId}',
+            path: {
+                'blogPostTagId': blogPostTagId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param blogPostTagId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static patchApiV2ContentServiceBlogPostTags(
+        tenantId: string,
+        blogPostTagId: string,
+        xApiVersion?: string,
+        requestBody?: BlogPostTagUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/v2/ContentService/BlogPostTags/{blogPostTagId}',
+            path: {
+                'blogPostTagId': blogPostTagId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param blogPostTagId
+     * @param xApiVersion
+     * @param requestBody
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static putApiV2ContentServiceBlogPostTags(
+        tenantId: string,
+        blogPostTagId: string,
+        xApiVersion?: string,
+        requestBody?: BlogPostTagUpdateDto,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/v2/ContentService/BlogPostTags/{blogPostTagId}',
+            path: {
+                'blogPostTagId': blogPostTagId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+    /**
+     * @param tenantId
+     * @param blogPostTagId
+     * @param xApiVersion
+     * @returns EmptyEnvelope OK
+     * @throws ApiError
+     */
+    public static deleteApiV2ContentServiceBlogPostTags(
+        tenantId: string,
+        blogPostTagId: string,
+        xApiVersion?: string,
+    ): CancelablePromise<EmptyEnvelope> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/v2/ContentService/BlogPostTags/{blogPostTagId}',
+            path: {
+                'blogPostTagId': blogPostTagId,
+            },
+            headers: {
+                'x-api-version': xApiVersion,
+            },
+            query: {
+                'tenantId': tenantId,
+            },
+            errors: {
+                401: `Unauthorized`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}