@easyedu/js-lsm-api 1.107.0 → 1.109.0

package/src/apis/ContentLibraryApi.ts

@@ -13,6 +13,21 @@
  */
 
 import * as runtime from '../runtime';
+import {
+    type ContentLibraryTag,
+    ContentLibraryTagFromJSON,
+    ContentLibraryTagToJSON,
+} from '../models/ContentLibraryTag';
+import {
+    type GetContentLibraryTagItemList,
+    GetContentLibraryTagItemListFromJSON,
+    GetContentLibraryTagItemListToJSON,
+} from '../models/GetContentLibraryTagItemList';
+import {
+    type GetContentLibraryTagList,
+    GetContentLibraryTagListFromJSON,
+    GetContentLibraryTagListToJSON,
+} from '../models/GetContentLibraryTagList';
 import {
     type GetContentLibraryVersion,
     GetContentLibraryVersionFromJSON,
@@ -43,6 +58,16 @@ import {
     GetResourceVersionUploadFromJSON,
     GetResourceVersionUploadToJSON,
 } from '../models/GetResourceVersionUpload';
+import {
+    type PostContentLibraryTag,
+    PostContentLibraryTagFromJSON,
+    PostContentLibraryTagToJSON,
+} from '../models/PostContentLibraryTag';
+import {
+    type PostContentLibraryTagMerge,
+    PostContentLibraryTagMergeFromJSON,
+    PostContentLibraryTagMergeToJSON,
+} from '../models/PostContentLibraryTagMerge';
 import {
     type PostResource,
     PostResourceFromJSON,
@@ -68,6 +93,11 @@ import {
     PostResourceVersionUploadFromJSON,
     PostResourceVersionUploadToJSON,
 } from '../models/PostResourceVersionUpload';
+import {
+    type PutContentLibraryTag,
+    PutContentLibraryTagFromJSON,
+    PutContentLibraryTagToJSON,
+} from '../models/PutContentLibraryTag';
 import {
     type PutResource,
     PutResourceFromJSON,
@@ -84,6 +114,10 @@ import {
     ResourceTypeToJSON,
 } from '../models/ResourceType';
 
+export interface DeleteContentLibraryTagRequest {
+    tagId: string;
+}
+
 export interface DeleteResourceVersionRequest {
     resourceId: string;
     versionId: string;
@@ -93,6 +127,29 @@ export interface GetContentLibraryItemListRequest {
     kind?: string;
     search?: string;
     resourceType?: ResourceType;
+    tagId?: string;
+    page?: number;
+    pageSize?: number;
+}
+
+export interface GetContentLibraryTagRequest {
+    tagId: string;
+}
+
+export interface GetContentLibraryTagItemListRequest {
+    tagId: string;
+    kind?: GetContentLibraryTagItemListKindEnum;
+    search?: string;
+    includeArchived?: boolean;
+    page?: number;
+    pageSize?: number;
+}
+
+export interface GetContentLibraryTagListRequest {
+    search?: string;
+    includeArchived?: boolean;
+    orderBy?: GetContentLibraryTagListOrderByEnum;
+    order?: GetContentLibraryTagListOrderEnum;
     page?: number;
     pageSize?: number;
 }
@@ -104,6 +161,7 @@ export interface GetResourceRequest {
 export interface GetResourceListRequest {
     search?: string;
     resourceType?: ResourceType;
+    tagId?: string;
     page?: number;
     pageSize?: number;
 }
@@ -117,6 +175,23 @@ export interface GetResourceVersionRequest {
     versionId: string;
 }
 
+export interface PostContentLibraryTagRequest {
+    postContentLibraryTag: PostContentLibraryTag;
+}
+
+export interface PostContentLibraryTagArchiveRequest {
+    tagId: string;
+}
+
+export interface PostContentLibraryTagMergeRequest {
+    tagId: string;
+    postContentLibraryTagMerge: PostContentLibraryTagMerge;
+}
+
+export interface PostContentLibraryTagRestoreRequest {
+    tagId: string;
+}
+
 export interface PostResourceRequest {
     postResource: PostResource;
 }
@@ -158,6 +233,11 @@ export interface PostResourceVersionUploadCompleteRequest {
     postResourceVersionComplete: PostResourceVersionComplete;
 }
 
+export interface PutContentLibraryTagRequest {
+    tagId: string;
+    putContentLibraryTag: PutContentLibraryTag;
+}
+
 export interface PutResourceRequest {
     resourceId: string;
     putResource: PutResource;
@@ -180,6 +260,50 @@ export interface PutResourceVersionUploadFileRequest {
  */
 export class ContentLibraryApi extends runtime.BaseAPI {
 
+    /**
+     * Creates request options for deleteContentLibraryTag without sending the request
+     */
+    async deleteContentLibraryTagRequestOpts(requestParameters: DeleteContentLibraryTagRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tagId'] == null) {
+            throw new runtime.RequiredError(
+                'tagId',
+                'Required parameter "tagId" was null or undefined when calling deleteContentLibraryTag().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/content-library/tags/{tagId}`;
+        urlPath = urlPath.replace('{tagId}', encodeURIComponent(String(requestParameters['tagId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete an archived, unused Content Library tag
+     */
+    async deleteContentLibraryTagRaw(requestParameters: DeleteContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteContentLibraryTagRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete an archived, unused Content Library tag
+     */
+    async deleteContentLibraryTag(requestParameters: DeleteContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteContentLibraryTagRaw(requestParameters, initOverrides);
+    }
+
     /**
      * Creates request options for deleteResourceVersion without sending the request
      */
@@ -250,6 +374,10 @@ export class ContentLibraryApi extends runtime.BaseAPI {
             queryParameters['resource_type'] = requestParameters['resourceType'];
         }
 
+        if (requestParameters['tagId'] != null) {
+            queryParameters['tag_id'] = requestParameters['tagId'];
+        }
+
         if (requestParameters['page'] != null) {
             queryParameters['page'] = requestParameters['page'];
         }
@@ -289,6 +417,177 @@ export class ContentLibraryApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getContentLibraryTag without sending the request
+     */
+    async getContentLibraryTagRequestOpts(requestParameters: GetContentLibraryTagRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tagId'] == null) {
+            throw new runtime.RequiredError(
+                'tagId',
+                'Required parameter "tagId" was null or undefined when calling getContentLibraryTag().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/content-library/tags/{tagId}`;
+        urlPath = urlPath.replace('{tagId}', encodeURIComponent(String(requestParameters['tagId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get a Content Library tag
+     */
+    async getContentLibraryTagRaw(requestParameters: GetContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ContentLibraryTag>> {
+        const requestOptions = await this.getContentLibraryTagRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ContentLibraryTagFromJSON(jsonValue));
+    }
+
+    /**
+     * Get a Content Library tag
+     */
+    async getContentLibraryTag(requestParameters: GetContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ContentLibraryTag> {
+        const response = await this.getContentLibraryTagRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getContentLibraryTagItemList without sending the request
+     */
+    async getContentLibraryTagItemListRequestOpts(requestParameters: GetContentLibraryTagItemListRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tagId'] == null) {
+            throw new runtime.RequiredError(
+                'tagId',
+                'Required parameter "tagId" was null or undefined when calling getContentLibraryTagItemList().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['kind'] != null) {
+            queryParameters['kind'] = requestParameters['kind'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        if (requestParameters['includeArchived'] != null) {
+            queryParameters['include_archived'] = requestParameters['includeArchived'];
+        }
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/content-library/tags/{tagId}/items`;
+        urlPath = urlPath.replace('{tagId}', encodeURIComponent(String(requestParameters['tagId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * List resources and quizzes associated with a tag
+     */
+    async getContentLibraryTagItemListRaw(requestParameters: GetContentLibraryTagItemListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryTagItemList>> {
+        const requestOptions = await this.getContentLibraryTagItemListRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetContentLibraryTagItemListFromJSON(jsonValue));
+    }
+
+    /**
+     * List resources and quizzes associated with a tag
+     */
+    async getContentLibraryTagItemList(requestParameters: GetContentLibraryTagItemListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryTagItemList> {
+        const response = await this.getContentLibraryTagItemListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getContentLibraryTagList without sending the request
+     */
+    async getContentLibraryTagListRequestOpts(requestParameters: GetContentLibraryTagListRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        if (requestParameters['includeArchived'] != null) {
+            queryParameters['include_archived'] = requestParameters['includeArchived'];
+        }
+
+        if (requestParameters['orderBy'] != null) {
+            queryParameters['order_by'] = requestParameters['orderBy'];
+        }
+
+        if (requestParameters['order'] != null) {
+            queryParameters['order'] = requestParameters['order'];
+        }
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/content-library/tags`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * List portal Content Library tags
+     */
+    async getContentLibraryTagListRaw(requestParameters: GetContentLibraryTagListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryTagList>> {
+        const requestOptions = await this.getContentLibraryTagListRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetContentLibraryTagListFromJSON(jsonValue));
+    }
+
+    /**
+     * List portal Content Library tags
+     */
+    async getContentLibraryTagList(requestParameters: GetContentLibraryTagListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryTagList> {
+        const response = await this.getContentLibraryTagListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getResource without sending the request
      */
@@ -348,6 +647,10 @@ export class ContentLibraryApi extends runtime.BaseAPI {
             queryParameters['resource_type'] = requestParameters['resourceType'];
         }
 
+        if (requestParameters['tagId'] != null) {
+            queryParameters['tag_id'] = requestParameters['tagId'];
+        }
+
         if (requestParameters['page'] != null) {
             queryParameters['page'] = requestParameters['page'];
         }
@@ -485,6 +788,198 @@ export class ContentLibraryApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for postContentLibraryTag without sending the request
+     */
+    async postContentLibraryTagRequestOpts(requestParameters: PostContentLibraryTagRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['postContentLibraryTag'] == null) {
+            throw new runtime.RequiredError(
+                'postContentLibraryTag',
+                'Required parameter "postContentLibraryTag" was null or undefined when calling postContentLibraryTag().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/content-library/tags`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostContentLibraryTagToJSON(requestParameters['postContentLibraryTag']),
+        };
+    }
+
+    /**
+     * Create a portal Content Library tag
+     */
+    async postContentLibraryTagRaw(requestParameters: PostContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ContentLibraryTag>> {
+        const requestOptions = await this.postContentLibraryTagRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ContentLibraryTagFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a portal Content Library tag
+     */
+    async postContentLibraryTag(requestParameters: PostContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ContentLibraryTag> {
+        const response = await this.postContentLibraryTagRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postContentLibraryTagArchive without sending the request
+     */
+    async postContentLibraryTagArchiveRequestOpts(requestParameters: PostContentLibraryTagArchiveRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tagId'] == null) {
+            throw new runtime.RequiredError(
+                'tagId',
+                'Required parameter "tagId" was null or undefined when calling postContentLibraryTagArchive().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/content-library/tags/{tagId}/archive`;
+        urlPath = urlPath.replace('{tagId}', encodeURIComponent(String(requestParameters['tagId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Archive a Content Library tag
+     */
+    async postContentLibraryTagArchiveRaw(requestParameters: PostContentLibraryTagArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ContentLibraryTag>> {
+        const requestOptions = await this.postContentLibraryTagArchiveRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ContentLibraryTagFromJSON(jsonValue));
+    }
+
+    /**
+     * Archive a Content Library tag
+     */
+    async postContentLibraryTagArchive(requestParameters: PostContentLibraryTagArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ContentLibraryTag> {
+        const response = await this.postContentLibraryTagArchiveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postContentLibraryTagMerge without sending the request
+     */
+    async postContentLibraryTagMergeRequestOpts(requestParameters: PostContentLibraryTagMergeRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tagId'] == null) {
+            throw new runtime.RequiredError(
+                'tagId',
+                'Required parameter "tagId" was null or undefined when calling postContentLibraryTagMerge().'
+            );
+        }
+
+        if (requestParameters['postContentLibraryTagMerge'] == null) {
+            throw new runtime.RequiredError(
+                'postContentLibraryTagMerge',
+                'Required parameter "postContentLibraryTagMerge" was null or undefined when calling postContentLibraryTagMerge().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/content-library/tags/{tagId}/merge`;
+        urlPath = urlPath.replace('{tagId}', encodeURIComponent(String(requestParameters['tagId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostContentLibraryTagMergeToJSON(requestParameters['postContentLibraryTagMerge']),
+        };
+    }
+
+    /**
+     * Merge a Content Library tag into another tag
+     */
+    async postContentLibraryTagMergeRaw(requestParameters: PostContentLibraryTagMergeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ContentLibraryTag>> {
+        const requestOptions = await this.postContentLibraryTagMergeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ContentLibraryTagFromJSON(jsonValue));
+    }
+
+    /**
+     * Merge a Content Library tag into another tag
+     */
+    async postContentLibraryTagMerge(requestParameters: PostContentLibraryTagMergeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ContentLibraryTag> {
+        const response = await this.postContentLibraryTagMergeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postContentLibraryTagRestore without sending the request
+     */
+    async postContentLibraryTagRestoreRequestOpts(requestParameters: PostContentLibraryTagRestoreRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tagId'] == null) {
+            throw new runtime.RequiredError(
+                'tagId',
+                'Required parameter "tagId" was null or undefined when calling postContentLibraryTagRestore().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/content-library/tags/{tagId}/restore`;
+        urlPath = urlPath.replace('{tagId}', encodeURIComponent(String(requestParameters['tagId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Restore a Content Library tag
+     */
+    async postContentLibraryTagRestoreRaw(requestParameters: PostContentLibraryTagRestoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ContentLibraryTag>> {
+        const requestOptions = await this.postContentLibraryTagRestoreRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ContentLibraryTagFromJSON(jsonValue));
+    }
+
+    /**
+     * Restore a Content Library tag
+     */
+    async postContentLibraryTagRestore(requestParameters: PostContentLibraryTagRestoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ContentLibraryTag> {
+        const response = await this.postContentLibraryTagRestoreRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for postResource without sending the request
      */
@@ -913,6 +1408,61 @@ export class ContentLibraryApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for putContentLibraryTag without sending the request
+     */
+    async putContentLibraryTagRequestOpts(requestParameters: PutContentLibraryTagRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['tagId'] == null) {
+            throw new runtime.RequiredError(
+                'tagId',
+                'Required parameter "tagId" was null or undefined when calling putContentLibraryTag().'
+            );
+        }
+
+        if (requestParameters['putContentLibraryTag'] == null) {
+            throw new runtime.RequiredError(
+                'putContentLibraryTag',
+                'Required parameter "putContentLibraryTag" was null or undefined when calling putContentLibraryTag().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/content-library/tags/{tagId}`;
+        urlPath = urlPath.replace('{tagId}', encodeURIComponent(String(requestParameters['tagId'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PutContentLibraryTagToJSON(requestParameters['putContentLibraryTag']),
+        };
+    }
+
+    /**
+     * Rename a Content Library tag
+     */
+    async putContentLibraryTagRaw(requestParameters: PutContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ContentLibraryTag>> {
+        const requestOptions = await this.putContentLibraryTagRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ContentLibraryTagFromJSON(jsonValue));
+    }
+
+    /**
+     * Rename a Content Library tag
+     */
+    async putContentLibraryTag(requestParameters: PutContentLibraryTagRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ContentLibraryTag> {
+        const response = await this.putContentLibraryTagRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for putResource without sending the request
      */
@@ -1094,3 +1644,28 @@ export class ContentLibraryApi extends runtime.BaseAPI {
     }
 
 }
+
+/**
+ * @export
+ */
+export const GetContentLibraryTagItemListKindEnum = {
+    Resource: 'resource',
+    Quiz: 'quiz'
+} as const;
+export type GetContentLibraryTagItemListKindEnum = typeof GetContentLibraryTagItemListKindEnum[keyof typeof GetContentLibraryTagItemListKindEnum];
+/**
+ * @export
+ */
+export const GetContentLibraryTagListOrderByEnum = {
+    Name: 'name',
+    UsageCount: 'usage_count'
+} as const;
+export type GetContentLibraryTagListOrderByEnum = typeof GetContentLibraryTagListOrderByEnum[keyof typeof GetContentLibraryTagListOrderByEnum];
+/**
+ * @export
+ */
+export const GetContentLibraryTagListOrderEnum = {
+    Asc: 'asc',
+    Desc: 'desc'
+} as const;
+export type GetContentLibraryTagListOrderEnum = typeof GetContentLibraryTagListOrderEnum[keyof typeof GetContentLibraryTagListOrderEnum];

package/src/apis/ContentLibraryQuizApi.ts

@@ -153,6 +153,7 @@ export interface GetLibraryQuizCriteriaRequest {
 export interface GetLibraryQuizListRequest {
     search?: string;
     includeArchived?: boolean;
+    tagId?: string;
     page?: number;
     pageSize?: number;
 }
@@ -505,6 +506,10 @@ export class ContentLibraryQuizApi extends runtime.BaseAPI {
             queryParameters['include_archived'] = requestParameters['includeArchived'];
         }
 
+        if (requestParameters['tagId'] != null) {
+            queryParameters['tag_id'] = requestParameters['tagId'];
+        }
+
         if (requestParameters['page'] != null) {
             queryParameters['page'] = requestParameters['page'];
         }