/* generated using openapi-typescript-codegen -- do no edit */
/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { Body_create_model_api_models_create_post } from '../models/Body_create_model_api_models_create_post';
import type { Body_update_model_api_models__model_id__put } from '../models/Body_update_model_api_models__model_id__put';
import type { CancelablePromise } from '../core/CancelablePromise';
import { OpenAPI } from '../core/OpenAPI';
import { request as __request } from '../core/request';
export class ModelService {
    /**
     * 创建模型
     * 创建模型
     *
     * Args:
     * tags: 模型标签，格式：性别_类别_尺寸_材质_颜色
     * cover_image: 封面图片文件
     * status: 状态，默认为1
     * db: 数据库会话
     *
     * Returns:
     * dict: 包含创建结果的响应
     * {
         * 'status': 创建状态,
         * 'data': {
             * 'id': 模型ID,
             * 'tag': {'sex': '性别', 'category': '类别', 'size': '尺寸', 'material': '材质', 'color': '颜色'},
             * 'cover_url': '封面URL',
             * 'status': 状态,
             * 'create_time': '创建时间'
             * },
             * 'msg': '提示信息'
             * }
             * @returns any Successful Response
             * @throws ApiError
             */
            public static createModelApiModelsCreatePost({
                formData,
            }: {
                formData: Body_create_model_api_models_create_post,
            }): CancelablePromise<any> {
                return __request(OpenAPI, {
                    method: 'POST',
                    url: '/api/models/create',
                    formData: formData,
                    mediaType: 'multipart/form-data',
                    errors: {
                        422: `Validation Error`,
                    },
                });
            }
            /**
             * 获取模特列表
             * 获取模型列表
             *
             * Args:
             * status: 状态筛选，1启用，0禁用，为空时获取所有
             * db: 数据库会话
             *
             * Returns:
             * dict: 包含模型列表的响应
             * {
                 * 'status': 查询状态,
                 * 'data': [模型信息列表],
                 * 'msg': '提示信息'
                 * }
                 * @returns any Successful Response
                 * @throws ApiError
                 */
                public static getModelsListApiModelsListGet({
                    status,
                }: {
                    /**
                     * 状态筛选，1启用，0禁用
                     */
                    status?: (number | null),
                }): CancelablePromise<any> {
                    return __request(OpenAPI, {
                        method: 'GET',
                        url: '/api/models/list',
                        query: {
                            'status': status,
                        },
                        errors: {
                            422: `Validation Error`,
                        },
                    });
                }
                /**
                 * 更新模型
                 * 更新模型信息
                 *
                 * Args:
                 * model_id: 模型ID
                 * tags: 更新的标签，格式：性别_类别_尺寸_材质_颜色（可选）
                 * cover_image: 更新的封面图片文件（可选）
                 * status: 更新的状态（可选）
                 * db: 数据库会话
                 *
                 * Returns:
                 * dict: 包含更新结果的响应
                 * @returns any Successful Response
                 * @throws ApiError
                 */
                public static updateModelApiModelsModelIdPut({
                    modelId,
                    formData,
                }: {
                    modelId: number,
                    formData?: Body_update_model_api_models__model_id__put,
                }): CancelablePromise<any> {
                    return __request(OpenAPI, {
                        method: 'PUT',
                        url: '/api/models/{model_id}',
                        path: {
                            'model_id': modelId,
                        },
                        formData: formData,
                        mediaType: 'multipart/form-data',
                        errors: {
                            422: `Validation Error`,
                        },
                    });
                }
                /**
                 * 删除单个模型
                 * 删除单个模型（软删除）
                 *
                 * Args:
                 * model_id: 模型ID
                 * db: 数据库会话
                 *
                 * Returns:
                 * dict: 删除结果
                 * @returns any Successful Response
                 * @throws ApiError
                 */
                public static deleteModelApiModelsModelIdDelete({
                    modelId,
                }: {
                    modelId: number,
                }): CancelablePromise<any> {
                    return __request(OpenAPI, {
                        method: 'DELETE',
                        url: '/api/models/{model_id}',
                        path: {
                            'model_id': modelId,
                        },
                        errors: {
                            422: `Validation Error`,
                        },
                    });
                }
                /**
                 * 删除模型，支持批量
                 * 批量删除模型（软删除）
                 *
                 * Args:
                 * model_ids: 模型ID列表
                 * db: 数据库会话
                 *
                 * Returns:
                 * dict: 删除结果
                 * {
                     * 'status': 删除状态,
                     * 'data': {
                         * 'total': 总数,
                         * 'success': 成功数,
                         * 'failed': 失败数
                         * },
                         * 'msg': '提示信息'
                         * }
                         * @returns any Successful Response
                         * @throws ApiError
                         */
                        public static removeModelsApiModelsRemovePost({
                            requestBody,
                        }: {
                            requestBody: Array<number>,
                        }): CancelablePromise<any> {
                            return __request(OpenAPI, {
                                method: 'POST',
                                url: '/api/models/remove',
                                body: requestBody,
                                mediaType: 'application/json',
                                errors: {
                                    422: `Validation Error`,
                                },
                            });
                        }
                        /**
                         * 根据标签筛选模型列表
                         * 根据标签筛选模型列表
                         * 支持格式：性别_类别_尺寸_材质_颜色，使用特殊匹配规则
                         *
                         * 匹配规则：
                         * - sex（性别）和 category（类别）：等值匹配（必须完全相同，AND逻辑）
                         * - size（尺寸）、material（材质）、color（颜色）：非等值匹配（所有字段都必须不同，AND逻辑）
                         *
                         * Args:
                         * tags: 标签字符串，格式：性别_类别_尺寸_材质_颜色
                         * status: 状态筛选，默认为1
                         * db: 数据库会话
                         *
                         * Returns:
                         * dict: 包含筛选结果的响应
                         * @returns any Successful Response
                         * @throws ApiError
                         */
                        public static getModelsByTagApiModelsByTagsGet({
                            tags,
                            status,
                        }: {
                            /**
                             * 标签，格式：性别_类别_尺寸_材质_颜色。例如: '女_上衣_长款_牛仔_红'
                             */
                            tags: string,
                            /**
                             * 状态筛选，1启用，0禁用
                             */
                            status?: (number | null),
                        }): CancelablePromise<any> {
                            return __request(OpenAPI, {
                                method: 'GET',
                                url: '/api/models/by/tags',
                                query: {
                                    'tags': tags,
                                    'status': status,
                                },
                                errors: {
                                    422: `Validation Error`,
                                },
                            });
                        }
                    }