canrd-main / canrd-erp-front · Commits

Commit 8b2bcc88aa953411670289913210e0b227f0ca8d

Authored by zhusen
1 parent da43036f
build: skipped

feat:add services

Inline Side-by-side
Showing 4 changed files with 769 additions and 2986 deletions
request.json 0 → 100644
  View file @8b2bcc8
  1 +{
  2 + "swagger": "2.0",
  3 + "info": {
  4 + "title": "内部订单",
  5 + "version": "last"
  6 + },
  7 + "basePath": "/",
  8 + "tags": [
  9 + {
  10 + "name": "公共分类",
  11 + "description": "公共分类"
  12 + }
  13 + ],
  14 + "schemes": ["http"],
  15 + "paths": {
  16 + "/erp/order/listByPage": {
  17 + "post": {
  18 + "tags": ["公共分类"],
  19 + "summary": "订单列表查询",
  20 + "description": "",
  21 + "consumes": ["application/json"],
  22 + "parameters": [
  23 + {
  24 + "name": "root",
  25 + "in": "body",
  26 + "schema": {
  27 + "type": "object",
  28 + "title": "title",
  29 + "properties": {
  30 + "current": {
  31 + "type": "number",
  32 + "title": "当前页码",
  33 + "description": "当前页码"
  34 + },
  35 + "size": {
  36 + "type": "string",
  37 + "title": "每页条数",
  38 + "description": "每页条数"
  39 + },
  40 + "search": {
  41 + "type": "object",
  42 + "properties": {
  43 + "mainOrderId": {
  44 + "type": "string",
  45 + "title": "主订单id",
  46 + "description": "主订单id"
  47 + },
  48 + "productName": {
  49 + "type": "string",
  50 + "title": "商品名称",
  51 + "description": "商品名称"
  52 + }
  53 + },
  54 + "required": ["mainOrderId", "productName"],
  55 + "title": "查询参数",
  56 + "description": "查询参数"
  57 + }
  58 + },
  59 + "required": ["current", "size", "search"]
  60 + }
  61 + }
  62 + ],
  63 + "responses": {
  64 + "200": {
  65 + "description": "successful operation",
  66 + "schema": {
  67 + "$schema": "http://json-schema.org/draft-04/schema#",
  68 + "type": "object",
  69 + "properties": {
  70 + "data": {
  71 + "type": "object",
  72 + "properties": {
  73 + "current": {
  74 + "type": "number"
  75 + },
  76 + "pages": {
  77 + "type": "number"
  78 + },
  79 + "records": {
  80 + "type": "array",
  81 + "items": {
  82 + "type": "object",
  83 + "properties": {
  84 + "main_order_id": {
  85 + "type": "number"
  86 + },
  87 + "sales_code": {
  88 + "type": "string"
  89 + },
  90 + "customer_name": {
  91 + "type": "string"
  92 + },
  93 + "customer_contact_number": {
  94 + "type": "string"
  95 + },
  96 + "customer_shipping_address": {
  97 + "type": "string"
  98 + },
  99 + "institution_contact_name": {
  100 + "type": "string"
  101 + },
  102 + "institution": {
  103 + "type": "string"
  104 + },
  105 + "main_order_create_time": {
  106 + "type": "string"
  107 + },
  108 + "main_order_update_time": {
  109 + "type": "string"
  110 + },
  111 + "main_order_create_by_name": {
  112 + "type": "string"
  113 + },
  114 + "main_order_update_by_name": {
  115 + "type": "null"
  116 + },
  117 + "btns": {
  118 + "type": "string",
  119 + "description": "权限按钮"
  120 + },
  121 + "sub_orders": {
  122 + "type": "array",
  123 + "items": {
  124 + "type": "object",
  125 + "properties": {
  126 + "sub_order_id": {
  127 + "type": "number"
  128 + },
  129 + "product_code": {
  130 + "type": "number"
  131 + },
  132 + "product_name": {
  133 + "type": "string"
  134 + },
  135 + "quantity": {
  136 + "type": "number"
  137 + },
  138 + "product_price": {
  139 + "type": "number"
  140 + },
  141 + "unit": {
  142 + "type": "string"
  143 + },
  144 + "parameters": {
  145 + "type": ["null", "string"]
  146 + },
  147 + "total_payment": {
  148 + "type": "number"
  149 + },
  150 + "sub_order_payment": {
  151 + "type": "number"
  152 + },
  153 + "is_cancel": {
  154 + "type": "number"
  155 + },
  156 + "logistics_status": {
  157 + "type": "string"
  158 + },
  159 + "payment_status": {
  160 + "type": "string"
  161 + },
  162 + "payment_method": {
  163 + "type": "string"
  164 + },
  165 + "payment_channel": {
  166 + "type": "string"
  167 + },
  168 + "payment_transaction_id": {
  169 + "type": ["string", "null"]
  170 + },
  171 + "invoice_information": {
  172 + "type": ["string", "null"]
  173 + },
  174 + "invoicing_status": {
  175 + "type": "string"
  176 + },
  177 + "product_belong_department": {
  178 + "type": "string"
  179 + },
  180 + "waybill_number": {
  181 + "type": ["number", "null"]
  182 + },
  183 + "notes": {
  184 + "type": ["string", "null"]
  185 + },
  186 + "examine_notes": {
  187 + "type": ["null", "string"]
  188 + },
  189 + "order_status": {
  190 + "type": "string"
  191 + },
  192 + "sub_order_create_time": {
  193 + "type": "string"
  194 + },
  195 + "sub_order_update_time": {
  196 + "type": "string"
  197 + },
  198 + "sub_order_create_by_name": {
  199 + "type": "string"
  200 + },
  201 + "sub_order_update_by_name": {
  202 + "type": "null"
  203 + },
  204 + "btns": {
  205 + "type": "string",
  206 + "description": "权限按钮"
  207 + }
  208 + },
  209 + "required": [
  210 + "sub_order_id",
  211 + "product_code",
  212 + "product_name",
  213 + "quantity",
  214 + "product_price",
  215 + "unit",
  216 + "parameters",
  217 + "total_payment",
  218 + "sub_order_payment",
  219 + "is_cancel",
  220 + "logistics_status",
  221 + "payment_status",
  222 + "payment_method",
  223 + "payment_channel",
  224 + "payment_transaction_id",
  225 + "invoice_information",
  226 + "invoicing_status",
  227 + "product_belong_department",
  228 + "waybill_number",
  229 + "notes",
  230 + "examine_notes",
  231 + "order_status",
  232 + "sub_order_create_time",
  233 + "sub_order_update_time",
  234 + "sub_order_create_by_name",
  235 + "sub_order_update_by_name",
  236 + "btns"
  237 + ]
  238 + }
  239 + }
  240 + },
  241 + "required": [
  242 + "main_order_id",
  243 + "sales_code",
  244 + "customer_name",
  245 + "customer_contact_number",
  246 + "customer_shipping_address",
  247 + "institution_contact_name",
  248 + "institution",
  249 + "main_order_create_time",
  250 + "main_order_update_time",
  251 + "main_order_create_by_name",
  252 + "main_order_update_by_name",
  253 + "sub_orders",
  254 + "btns"
  255 + ]
  256 + }
  257 + },
  258 + "total": {
  259 + "type": "number"
  260 + },
  261 + "size": {
  262 + "type": "number"
  263 + }
  264 + },
  265 + "required": ["size"]
  266 + },
  267 + "message": {
  268 + "type": "string"
  269 + },
  270 + "code": {
  271 + "type": "number"
  272 + }
  273 + }
  274 + }
  275 + }
  276 + }
  277 + }
  278 + },
  279 + "/erp/order/add": {
  280 + "post": {
  281 + "tags": ["公共分类"],
  282 + "summary": "订单新增",
  283 + "description": "",
  284 + "consumes": ["application/json"],
  285 + "parameters": [
  286 + {
  287 + "name": "add_token",
  288 + "in": "header",
  289 + "description": "add_token (Only:undefined)",
  290 + "required": true,
  291 + "type": "string"
  292 + },
  293 + {
  294 + "name": "root",
  295 + "in": "body",
  296 + "schema": {
  297 + "$schema": "http://json-schema.org/draft-04/schema#",
  298 + "type": "object",
  299 + "properties": {
  300 + "sales_code": {
  301 + "type": "string"
  302 + },
  303 + "customer_name": {
  304 + "type": "string"
  305 + },
  306 + "customer_contact_number": {
  307 + "type": "string"
  308 + },
  309 + "customer_shipping_address": {
  310 + "type": "string"
  311 + },
  312 + "institution_contact_name": {
  313 + "type": "string"
  314 + },
  315 + "institution": {
  316 + "type": "string"
  317 + },
  318 + "sub_orders": {
  319 + "type": "array",
  320 + "items": {
  321 + "type": "object",
  322 + "properties": {
  323 + "product_code": {
  324 + "type": "number"
  325 + },
  326 + "product_name": {
  327 + "type": "string"
  328 + },
  329 + "quantity": {
  330 + "type": "number"
  331 + },
  332 + "product_price": {
  333 + "type": "number"
  334 + },
  335 + "unit": {
  336 + "type": "string"
  337 + },
  338 + "parameters": {
  339 + "type": "string"
  340 + },
  341 + "total_payment": {
  342 + "type": "number"
  343 + },
  344 + "sub_order_payment": {
  345 + "type": "number"
  346 + },
  347 + "payment_status": {
  348 + "type": "string"
  349 + },
  350 + "payment_method": {
  351 + "type": "string"
  352 + },
  353 + "payment_channel": {
  354 + "type": "string"
  355 + },
  356 + "payment_transaction_id": {
  357 + "type": "string",
  358 + "description": "预付必填"
  359 + },
  360 + "invoice_information": {
  361 + "type": "string",
  362 + "description": "需要开票必填"
  363 + },
  364 + "invoicing_status": {
  365 + "type": "string"
  366 + },
  367 + "product_belong_department": {
  368 + "type": "string"
  369 + },
  370 + "notes": {
  371 + "type": "string"
  372 + }
  373 + },
  374 + "required": [
  375 + "product_code",
  376 + "product_name",
  377 + "quantity",
  378 + "product_price",
  379 + "unit",
  380 + "parameters",
  381 + "total_payment",
  382 + "sub_order_payment",
  383 + "payment_status",
  384 + "payment_method",
  385 + "payment_channel",
  386 + "invoicing_status",
  387 + "product_belong_department"
  388 + ]
  389 + }
  390 + }
  391 + },
  392 + "required": [
  393 + "sales_code",
  394 + "customer_name",
  395 + "customer_contact_number",
  396 + "customer_shipping_address",
  397 + "institution_contact_name",
  398 + "sub_orders",
  399 + "institution"
  400 + ]
  401 + }
  402 + }
  403 + ],
  404 + "responses": {
  405 + "200": {
  406 + "description": "successful operation",
  407 + "schema": {
  408 + "$schema": "http://json-schema.org/draft-04/schema#",
  409 + "type": "object",
  410 + "properties": {
  411 + "message": {
  412 + "type": "string"
  413 + },
  414 + "code": {
  415 + "type": "number"
  416 + }
  417 + }
  418 + }
  419 + }
  420 + }
  421 + }
  422 + },
  423 + "/erp/order/update": {
  424 + "post": {
  425 + "tags": ["公共分类"],
  426 + "summary": "订单编辑",
  427 + "description": "",
  428 + "consumes": ["application/json"],
  429 + "parameters": [
  430 + {
  431 + "name": "root",
  432 + "in": "body",
  433 + "schema": {
  434 + "$schema": "http://json-schema.org/draft-04/schema#",
  435 + "type": "object",
  436 + "properties": {
  437 + "sales_code": {
  438 + "type": "string"
  439 + },
  440 + "customer_name": {
  441 + "type": "string"
  442 + },
  443 + "customer_contact_number": {
  444 + "type": "string"
  445 + },
  446 + "customer_shipping_address": {
  447 + "type": "string"
  448 + },
  449 + "institution_contact_name": {
  450 + "type": "string"
  451 + },
  452 + "institution": {
  453 + "type": "string"
  454 + },
  455 + "sub_orders": {
  456 + "type": "array",
  457 + "items": {
  458 + "type": "object",
  459 + "properties": {
  460 + "product_code": {
  461 + "type": "number"
  462 + },
  463 + "product_name": {
  464 + "type": "string"
  465 + },
  466 + "quantity": {
  467 + "type": "number"
  468 + },
  469 + "product_price": {
  470 + "type": "number"
  471 + },
  472 + "unit": {
  473 + "type": "string"
  474 + },
  475 + "parameters": {
  476 + "type": "string"
  477 + },
  478 + "total_payment": {
  479 + "type": "number"
  480 + },
  481 + "sub_order_payment": {
  482 + "type": "number"
  483 + },
  484 + "payment_status": {
  485 + "type": "string"
  486 + },
  487 + "payment_method": {
  488 + "type": "string"
  489 + },
  490 + "payment_channel": {
  491 + "type": "string"
  492 + },
  493 + "payment_transaction_id": {
  494 + "type": "string"
  495 + },
  496 + "invoice_information": {
  497 + "type": "string"
  498 + },
  499 + "invoicing_status": {
  500 + "type": "string"
  501 + },
  502 + "product_belong_department": {
  503 + "type": "string"
  504 + },
  505 + "notes": {
  506 + "type": "string"
  507 + }
  508 + },
  509 + "required": [
  510 + "product_code",
  511 + "product_name",
  512 + "quantity",
  513 + "product_price",
  514 + "unit",
  515 + "parameters",
  516 + "total_payment",
  517 + "sub_order_payment",
  518 + "payment_status",
  519 + "payment_method",
  520 + "payment_channel",
  521 + "invoicing_status",
  522 + "product_belong_department"
  523 + ]
  524 + }
  525 + }
  526 + },
  527 + "required": [
  528 + "sales_code",
  529 + "customer_name",
  530 + "customer_contact_number",
  531 + "customer_shipping_address",
  532 + "institution_contact_name",
  533 + "institution",
  534 + "sub_orders"
  535 + ]
  536 + }
  537 + }
  538 + ],
  539 + "responses": {
  540 + "200": {
  541 + "description": "successful operation",
  542 + "schema": {
  543 + "$schema": "http://json-schema.org/draft-04/schema#",
  544 + "type": "object",
  545 + "properties": {
  546 + "message": {
  547 + "type": "string"
  548 + },
  549 + "code": {
  550 + "type": "number"
  551 + }
  552 + }
  553 + }
  554 + }
  555 + }
  556 + }
  557 + },
  558 + "definitions": {}
  559 + }
  560 +}
src/services/definition.ts
  View file @8b2bcc8
@@ -2,362 +2,3 @@ @@ -2,362 +2,3 @@
2 /* tslint:disable */ 2 /* tslint:disable */
3 /** Do not modify manually. 3 /** Do not modify manually.
4 content is generated automatically by `ts-gear`. */ 4 content is generated automatically by `ts-gear`. */
5 -  
6 -export interface ZFWJInternalPkgRequestAddDicReq {  
7 - /**  
8 - * @example  
9 - * 标签1  
10 - */  
11 - Description: string;  
12 - /**  
13 - * @example  
14 - * 1  
15 - */  
16 - SortOrder: number;  
17 - /**  
18 - * @example  
19 - * 用户标签  
20 - */  
21 - Type: string;  
22 -}  
23 -  
24 -export interface ZFWJInternalPkgRequestCreateGdmTaskRequest {  
25 - DataSource: Array<number>;  
26 - Faction: number;  
27 - Model: string;  
28 - Scenario: number;  
29 - TacticalLevel: number;  
30 - TaskName: string;  
31 - TaskStatus: number;  
32 - UserTags: Array<number>;  
33 -}  
34 -  
35 -export interface ZFWJInternalPkgRequestCreateGdmUploadRequest {  
36 - FileUrl: Array<number>;  
37 - GameScenario: number;  
38 - Model: string;  
39 - TacticalLevel: number;  
40 - TaskName: string;  
41 -}  
42 -  
43 -export interface ZFWJInternalPkgRequestCreateOrsRequest {  
44 - EndTime: string;  
45 - FileId: string;  
46 - StartTime: string;  
47 -}  
48 -  
49 -export interface ZFWJInternalPkgRequestCreateStrategyRuleRequest {  
50 - /**  
51 - * @example  
52 - * 1  
53 - */  
54 - Faction?: number;  
55 - /**  
56 - * @example  
57 - * 1  
58 - */  
59 - Scenario?: number;  
60 - /**  
61 - * @example  
62 - * 1  
63 - */  
64 - Source: number;  
65 - StateMachineResult?: Array<number>;  
66 - /**  
67 - * @example  
68 - * 厉害的战法  
69 - */  
70 - StrategyName: string;  
71 - /**  
72 - * @example  
73 - * 1  
74 - */  
75 - StrategyType: string;  
76 - TacticalLevel?: number;  
77 - /**  
78 - * @example  
79 - * 1  
80 - */  
81 - TaskType: number;  
82 -}  
83 -  
84 -export interface ZFWJInternalPkgRequestCreateTmtRequest {  
85 - /**  
86 - * @example  
87 - * 作战手册1挖掘  
88 - */  
89 - TaskName: string;  
90 - /**  
91 - * @example  
92 - * 1  
93 - */  
94 - TextType: number;  
95 - TextUrl: Array<number>;  
96 -}  
97 -  
98 -export interface ZFWJInternalPkgRequestDeleteDicReq {  
99 - /**  
100 - * @example  
101 - * 1  
102 - */  
103 - Id: number;  
104 -}  
105 -  
106 -export interface ZFWJInternalPkgRequestDeleteUserRequest {  
107 - /**  
108 - * @example  
109 - * alan  
110 - */  
111 - username?: string;  
112 -}  
113 -  
114 -export interface ZFWJInternalPkgRequestGetDicList {  
115 - /**  
116 - * @example  
117 - * 1  
118 - */  
119 - PageNum: number;  
120 - /**  
121 - * @example  
122 - * 10  
123 - */  
124 - PageSize: number;  
125 - /**  
126 - * @example  
127 - * 标签  
128 - */  
129 - Type?: string;  
130 -}  
131 -  
132 -export interface ZFWJInternalPkgRequestLoginRequest {  
133 - /**  
134 - * @example  
135 - * 123456  
136 - */  
137 - password: string;  
138 - /**  
139 - * @example  
140 - * alan  
141 - */  
142 - username: string;  
143 -}  
144 -  
145 -export interface ZFWJInternalPkgRequestOpenTaskRequest {  
146 - TaskId: string;  
147 -}  
148 -  
149 -export interface ZFWJInternalPkgRequestRegisterRequest {  
150 - /**  
151 - * @example  
152 - * alan  
153 - */  
154 - nickname?: string;  
155 - /**  
156 - * @example  
157 - * 123456  
158 - */  
159 - password: string;  
160 - /**  
161 - * @example  
162 - * 1  
163 - */  
164 - type?: number;  
165 - /**  
166 - * @example  
167 - * alan  
168 - */  
169 - username: string;  
170 -}  
171 -  
172 -export interface ZFWJInternalPkgRequestStrategyRuleArchiveRequest {  
173 - /**  
174 - * @example  
175 - * 1  
176 - */  
177 - Faction?: number;  
178 - /**  
179 - * @example  
180 - * 1  
181 - */  
182 - Id: string;  
183 - /**  
184 - * @example  
185 - * 1  
186 - */  
187 - OriginalText?: string;  
188 - /**  
189 - * @example  
190 - * 1  
191 - */  
192 - Scenario?: number;  
193 - StateMachineResult?: Array<number>;  
194 - /**  
195 - * @example  
196 - * 1  
197 - */  
198 - StrategyName: string;  
199 - /**  
200 - * @example  
201 - * 1  
202 - */  
203 - StrategyType?: string;  
204 - /**  
205 - * @example  
206 - * 1  
207 - */  
208 - TacticalLevel?: number;  
209 - /**  
210 - * @example  
211 - * 1  
212 - */  
213 - TaskId: string;  
214 - /**  
215 - * @example  
216 - * 1  
217 - */  
218 - TaskName: string;  
219 - /**  
220 - * @example  
221 - * 1  
222 - */  
223 - TaskType?: number;  
224 -}  
225 -  
226 -export interface ZFWJInternalPkgRequestUpdateDicReq {  
227 - /**  
228 - * @example  
229 - * 标签1  
230 - */  
231 - Description?: string;  
232 - Id: number;  
233 - /**  
234 - * @example  
235 - * 1  
236 - */  
237 - SortOrder?: number;  
238 - /**  
239 - * @example  
240 - * 字典类型  
241 - */  
242 - Type?: string;  
243 -}  
244 -  
245 -export interface ZFWJInternalPkgRequestUpdateGameDataMiningResultRequest {  
246 - Id: string;  
247 - StateMachineResult?: Array<number>;  
248 - StrategyName?: string;  
249 - StrategyType?: string;  
250 -}  
251 -  
252 -export interface ZFWJInternalPkgRequestUpdateGdmUploadRequest {  
253 - FileUrl: Array<number>;  
254 - Id: string;  
255 - TaskName: string;  
256 -}  
257 -  
258 -export interface ZFWJInternalPkgRequestUpdateOrsRequest {  
259 - EndTime: string;  
260 - SliceId: string;  
261 - StartTime: string;  
262 -}  
263 -  
264 -export interface ZFWJInternalPkgRequestUpdateProfileRequest {  
265 - /**  
266 - * @example  
267 - * alan  
268 - */  
269 - nickname?: string;  
270 - /**  
271 - * @example  
272 - * 123456  
273 - */  
274 - password?: string;  
275 - /**  
276 - * @example  
277 - * 1  
278 - */  
279 - type?: number;  
280 - /**  
281 - * @example  
282 - * alan  
283 - */  
284 - username?: string;  
285 -}  
286 -  
287 -export interface ZFWJInternalPkgRequestUpdateStrategyRuleRequest {  
288 - /**  
289 - * @example  
290 - * 1  
291 - */  
292 - Faction?: number;  
293 - /**  
294 - * @example  
295 - * 1  
296 - */  
297 - Id: string;  
298 - /**  
299 - * @example  
300 - * 1  
301 - */  
302 - Scenario?: number;  
303 - StateMachineResult?: Array<number>;  
304 - /**  
305 - * @example  
306 - * 厉害的战法  
307 - */  
308 - StrategyName?: string;  
309 - /**  
310 - * @example  
311 - * 1  
312 - */  
313 - StrategyType?: string;  
314 - /**  
315 - * @example  
316 - * 1  
317 - */  
318 - TacticalLevel?: number;  
319 -}  
320 -  
321 -export interface ZFWJInternalPkgRequestUpdateTmrRequest {  
322 - GraphResult?: Array<number>;  
323 - /**  
324 - * @example  
325 - * 1  
326 - */  
327 - Id: string;  
328 - /**  
329 - * @example  
330 - * xxxxxxxx  
331 - */  
332 - OriginalText?: string;  
333 - StateMachineResult?: Array<number>;  
334 - /**  
335 - * @example  
336 - * 1  
337 - */  
338 - StorageStatus?: number;  
339 - /**  
340 - * @example  
341 - * 高速Yo-Yo  
342 - */  
343 - StrategyName?: string;  
344 -}  
345 -  
346 -export interface ZFWJInternalPkgRequestUpdateTmtRequest {  
347 - /**  
348 - * @example  
349 - * 1  
350 - */  
351 - TaskId: string;  
352 - /**  
353 - * @example  
354 - * 作战手册1挖掘  
355 - */  
356 - TaskName: string;  
357 -}  
358 -  
359 -export interface ZFWJInternalPkgResponseResponse {  
360 - code?: number;  
361 - data?: any;  
362 - message?: string;  
363 -}  
src/services/request.ts
  View file @8b2bcc8
@@ -3,2299 +3,122 @@ @@ -3,2299 +3,122 @@
3 /** Do not modify manually. 3 /** Do not modify manually.
4 content is generated automatically by `ts-gear`. */ 4 content is generated automatically by `ts-gear`. */
5 import { request as requester } from "umi"; 5 import { request as requester } from "umi";
6 -import type {  
7 - ZFWJInternalPkgRequestUpdateProfileRequest,  
8 - ZFWJInternalPkgResponseResponse,  
9 - ZFWJInternalPkgRequestDeleteUserRequest,  
10 - ZFWJInternalPkgRequestAddDicReq,  
11 - ZFWJInternalPkgRequestDeleteDicReq,  
12 - ZFWJInternalPkgRequestGetDicList,  
13 - ZFWJInternalPkgRequestUpdateDicReq,  
14 - ZFWJInternalPkgRequestCreateGdmTaskRequest,  
15 - ZFWJInternalPkgRequestCreateGdmUploadRequest,  
16 - ZFWJInternalPkgRequestUpdateGdmUploadRequest,  
17 - ZFWJInternalPkgRequestUpdateGameDataMiningResultRequest,  
18 - ZFWJInternalPkgRequestOpenTaskRequest,  
19 - ZFWJInternalPkgRequestUpdateOrsRequest,  
20 - ZFWJInternalPkgRequestCreateOrsRequest,  
21 - ZFWJInternalPkgRequestLoginRequest,  
22 - ZFWJInternalPkgRequestRegisterRequest,  
23 - ZFWJInternalPkgRequestUpdateStrategyRuleRequest,  
24 - ZFWJInternalPkgRequestCreateStrategyRuleRequest,  
25 - ZFWJInternalPkgRequestStrategyRuleArchiveRequest,  
26 - ZFWJInternalPkgRequestUpdateTmtRequest,  
27 - ZFWJInternalPkgRequestCreateTmtRequest,  
28 - ZFWJInternalPkgRequestUpdateTmrRequest,  
29 -} from "./definition";  
30 -  
31 -/** @description request parameter type for putAdminUser */  
32 -export interface PutAdminUserOption {  
33 - /**  
34 - * @description  
35 - * 用户信息  
36 - */  
37 - body: {  
38 - /**  
39 - @description  
40 - 用户信息 */  
41 - request: ZFWJInternalPkgRequestUpdateProfileRequest;  
42 - };  
43 -}  
44 -  
45 -/** @description response type for putAdminUser */  
46 -export interface PutAdminUserResponse {  
47 - /**  
48 - * @description  
49 - * OK  
50 - */  
51 - 200: ZFWJInternalPkgResponseResponse;  
52 -}  
53 -  
54 -export type PutAdminUserResponseSuccess = PutAdminUserResponse[200];  
55 -/**  
56 - * @description  
57 - * 更新用户信息  
58 - * @tags 用户模块  
59 - * @produces application/json  
60 - * @consumes application/json  
61 - */  
62 -export const putAdminUser = /* #__PURE__ */ (() => {  
63 - const method = "put";  
64 - const url = "/admin/user";  
65 - function request(  
66 - option: PutAdminUserOption  
67 - ): Promise<PutAdminUserResponseSuccess> {  
68 - return requester(request.url, {  
69 - method: request.method,  
70 - ...option,  
71 - }) as unknown as Promise<PutAdminUserResponseSuccess>;  
72 - }  
73 -  
74 - /** http method */  
75 - request.method = method;  
76 - /** request url */  
77 - request.url = url;  
78 - return request;  
79 -})();  
80 -  
81 -/** @description request parameter type for deleteAdminUserDelete */  
82 -export interface DeleteAdminUserDeleteOption {  
83 - /**  
84 - * @description  
85 - * 删除用户  
86 - */  
87 - body: {  
88 - /**  
89 - @description  
90 - 删除用户 */  
91 - request: ZFWJInternalPkgRequestDeleteUserRequest;  
92 - };  
93 -}  
94 -  
95 -/** @description response type for deleteAdminUserDelete */  
96 -export interface DeleteAdminUserDeleteResponse {  
97 - /**  
98 - * @description  
99 - * OK  
100 - */  
101 - 200: ZFWJInternalPkgResponseResponse;  
102 -}  
103 -  
104 -export type DeleteAdminUserDeleteResponseSuccess =  
105 - DeleteAdminUserDeleteResponse[200];  
106 -/**  
107 - * @description  
108 - * 删除用户  
109 - * @tags 用户模块  
110 - * @produces application/json  
111 - * @consumes application/json  
112 - */  
113 -export const deleteAdminUserDelete = /* #__PURE__ */ (() => {  
114 - const method = "delete";  
115 - const url = "/admin/user/delete";  
116 - function request(  
117 - option: DeleteAdminUserDeleteOption  
118 - ): Promise<DeleteAdminUserDeleteResponseSuccess> {  
119 - return requester(request.url, {  
120 - method: request.method,  
121 - ...option,  
122 - }) as unknown as Promise<DeleteAdminUserDeleteResponseSuccess>;  
123 - }  
124 -  
125 - /** http method */  
126 - request.method = method;  
127 - /** request url */  
128 - request.url = url;  
129 - return request;  
130 -})();  
131 -  
132 -/** @description request parameter type for getAdminUserList */  
133 -export interface GetAdminUserListOption {  
134 - /**  
135 - * @description  
136 - * PageNum  
137 - */  
138 - query: {  
139 - /**  
140 - @description  
141 - PageNum */  
142 - PageNum: number;  
143 - /**  
144 - @description  
145 - PageSize */  
146 - PageSize: number;  
147 - };  
148 -}  
149 -  
150 -/** @description response type for getAdminUserList */  
151 -export interface GetAdminUserListResponse {  
152 - /**  
153 - * @description  
154 - * OK  
155 - */  
156 - 200: ZFWJInternalPkgResponseResponse;  
157 -}  
158 -  
159 -export type GetAdminUserListResponseSuccess = GetAdminUserListResponse[200];  
160 -/**  
161 - * @description  
162 - * 获取用户列表  
163 - * @tags 用户模块  
164 - * @produces application/json  
165 - * @consumes application/json  
166 - */  
167 -export const getAdminUserList = /* #__PURE__ */ (() => {  
168 - const method = "get";  
169 - const url = "/admin/user/list";  
170 - function request(  
171 - option: GetAdminUserListOption  
172 - ): Promise<GetAdminUserListResponseSuccess> {  
173 - return requester(request.url, {  
174 - method: request.method,  
175 - ...option,  
176 - }) as unknown as Promise<GetAdminUserListResponseSuccess>;  
177 - }  
178 -  
179 - /** http method */  
180 - request.method = method;  
181 - /** request url */  
182 - request.url = url;  
183 - return request;  
184 -})();  
185 -  
186 -/** @description request parameter type for putDictionaryCreate */  
187 -export interface PutDictionaryCreateOption {  
188 - /**  
189 - * @description  
190 - * 字典信息  
191 - */  
192 - body: {  
193 - /**  
194 - @description  
195 - 字典信息 */  
196 - request: Array<ZFWJInternalPkgRequestAddDicReq>;  
197 - };  
198 -}  
199 -  
200 -/** @description response type for putDictionaryCreate */  
201 -export interface PutDictionaryCreateResponse {  
202 - /**  
203 - * @description  
204 - * OK  
205 - */  
206 - 200: ZFWJInternalPkgResponseResponse;  
207 -}  
208 -  
209 -export type PutDictionaryCreateResponseSuccess =  
210 - PutDictionaryCreateResponse[200];  
211 -/**  
212 - * @description  
213 - * 新增字典  
214 - * 新增字典  
215 - * @tags 字典  
216 - * @produces application/json  
217 - * @consumes application/json  
218 - */  
219 -export const putDictionaryCreate = /* #__PURE__ */ (() => {  
220 - const method = "put";  
221 - const url = "/dictionary/create";  
222 - function request(  
223 - option: PutDictionaryCreateOption  
224 - ): Promise<PutDictionaryCreateResponseSuccess> {  
225 - return requester(request.url, {  
226 - method: request.method,  
227 - ...option,  
228 - }) as unknown as Promise<PutDictionaryCreateResponseSuccess>;  
229 - }  
230 -  
231 - /** http method */  
232 - request.method = method;  
233 - /** request url */  
234 - request.url = url;  
235 - return request;  
236 -})();  
237 -  
238 -/** @description request parameter type for deleteDictionaryDelete */  
239 -export interface DeleteDictionaryDeleteOption {  
240 - /**  
241 - * @description  
242 - * 字典id  
243 - */  
244 - body: {  
245 - /**  
246 - @description  
247 - 字典id */  
248 - request: ZFWJInternalPkgRequestDeleteDicReq;  
249 - };  
250 -}  
251 -  
252 -/** @description response type for deleteDictionaryDelete */  
253 -export interface DeleteDictionaryDeleteResponse {  
254 - /**  
255 - * @description  
256 - * OK  
257 - */  
258 - 200: ZFWJInternalPkgResponseResponse;  
259 -}  
260 -  
261 -export type DeleteDictionaryDeleteResponseSuccess =  
262 - DeleteDictionaryDeleteResponse[200];  
263 -/**  
264 - * @description  
265 - * 删除字典  
266 - * 删除字典  
267 - * @tags 字典  
268 - * @produces application/json  
269 - * @consumes application/json  
270 - */  
271 -export const deleteDictionaryDelete = /* #__PURE__ */ (() => {  
272 - const method = "delete";  
273 - const url = "/dictionary/delete";  
274 - function request(  
275 - option: DeleteDictionaryDeleteOption  
276 - ): Promise<DeleteDictionaryDeleteResponseSuccess> {  
277 - return requester(request.url, {  
278 - method: request.method,  
279 - ...option,  
280 - }) as unknown as Promise<DeleteDictionaryDeleteResponseSuccess>;  
281 - }  
282 -  
283 - /** http method */  
284 - request.method = method;  
285 - /** request url */  
286 - request.url = url;  
287 - return request;  
288 -})();  
289 -  
290 -/** @description response type for getDictionaryGetAll */  
291 -export interface GetDictionaryGetAllResponse {  
292 - /**  
293 - * @description  
294 - * OK  
295 - */  
296 - 200: ZFWJInternalPkgResponseResponse;  
297 -}  
298 -  
299 -export type GetDictionaryGetAllResponseSuccess =  
300 - GetDictionaryGetAllResponse[200];  
301 -/**  
302 - * @description  
303 - * 获取全量字典  
304 - * 获取全量字典  
305 - * @tags 字典  
306 - * @produces application/json  
307 - * @consumes application/json  
308 - */  
309 -export const getDictionaryGetAll = /* #__PURE__ */ (() => {  
310 - const method = "get";  
311 - const url = "/dictionary/get-all";  
312 - function request(): Promise<GetDictionaryGetAllResponseSuccess> {  
313 - return requester(request.url, {  
314 - method: request.method,  
315 - }) as unknown as Promise<GetDictionaryGetAllResponseSuccess>;  
316 - }  
317 -  
318 - /** http method */  
319 - request.method = method;  
320 - /** request url */  
321 - request.url = url;  
322 - return request;  
323 -})();  
324 -  
325 -/** @description request parameter type for postDictionaryList */  
326 -export interface PostDictionaryListOption {  
327 - /**  
328 - * @description  
329 - * 当前页,页面大小  
330 - */  
331 - body: {  
332 - /**  
333 - @description  
334 - 当前页,页面大小 */  
335 - request: ZFWJInternalPkgRequestGetDicList;  
336 - };  
337 -}  
338 -  
339 -/** @description response type for postDictionaryList */  
340 -export interface PostDictionaryListResponse {  
341 - /**  
342 - * @description  
343 - * OK  
344 - */  
345 - 200: ZFWJInternalPkgResponseResponse;  
346 -}  
347 -  
348 -export type PostDictionaryListResponseSuccess = PostDictionaryListResponse[200];  
349 -/**  
350 - * @description  
351 - * 获取字典列表  
352 - * 获取字典列表  
353 - * @tags 字典  
354 - * @produces application/json  
355 - * @consumes application/json  
356 - */  
357 -export const postDictionaryList = /* #__PURE__ */ (() => {  
358 - const method = "post";  
359 - const url = "/dictionary/list";  
360 - function request(  
361 - option: PostDictionaryListOption  
362 - ): Promise<PostDictionaryListResponseSuccess> {  
363 - return requester(request.url, {  
364 - method: request.method,  
365 - ...option,  
366 - }) as unknown as Promise<PostDictionaryListResponseSuccess>;  
367 - }  
368 -  
369 - /** http method */  
370 - request.method = method;  
371 - /** request url */  
372 - request.url = url;  
373 - return request;  
374 -})();  
375 -  
376 -/** @description request parameter type for postDictionaryUpdate */  
377 -export interface PostDictionaryUpdateOption {  
378 - /**  
379 - * @description  
380 - * 字典信息  
381 - */  
382 - body: {  
383 - /**  
384 - @description  
385 - 字典信息 */  
386 - request: ZFWJInternalPkgRequestUpdateDicReq;  
387 - };  
388 -}  
389 -  
390 -/** @description response type for postDictionaryUpdate */  
391 -export interface PostDictionaryUpdateResponse {  
392 - /**  
393 - * @description  
394 - * OK  
395 - */  
396 - 200: ZFWJInternalPkgResponseResponse;  
397 -}  
398 -  
399 -export type PostDictionaryUpdateResponseSuccess =  
400 - PostDictionaryUpdateResponse[200];  
401 -/**  
402 - * @description  
403 - * 更新字典信息  
404 - * 更新字典信息  
405 - * @tags 字典  
406 - * @produces application/json  
407 - * @consumes application/json  
408 - */  
409 -export const postDictionaryUpdate = /* #__PURE__ */ (() => {  
410 - const method = "post";  
411 - const url = "/dictionary/update";  
412 - function request(  
413 - option: PostDictionaryUpdateOption  
414 - ): Promise<PostDictionaryUpdateResponseSuccess> {  
415 - return requester(request.url, {  
416 - method: request.method,  
417 - ...option,  
418 - }) as unknown as Promise<PostDictionaryUpdateResponseSuccess>;  
419 - }  
420 -  
421 - /** http method */  
422 - request.method = method;  
423 - /** request url */  
424 - request.url = url;  
425 - return request;  
426 -})();  
427 -  
428 -/** @description request parameter type for postGamedataminingCreateMiningTask */  
429 -export interface PostGamedataminingCreateMiningTaskOption {  
430 - /**  
431 - * @description  
432 - * 创建博弈数据挖掘任务  
433 - */  
434 - body: {  
435 - /**  
436 - @description  
437 - 创建博弈数据挖掘任务 */  
438 - request: ZFWJInternalPkgRequestCreateGdmTaskRequest;  
439 - };  
440 -}  
441 -  
442 -/** @description response type for postGamedataminingCreateMiningTask */  
443 -export interface PostGamedataminingCreateMiningTaskResponse {  
444 - /**  
445 - * @description  
446 - * OK  
447 - */  
448 - 200: ZFWJInternalPkgResponseResponse;  
449 -}  
450 -  
451 -export type PostGamedataminingCreateMiningTaskResponseSuccess =  
452 - PostGamedataminingCreateMiningTaskResponse[200];  
453 -/**  
454 - * @description  
455 - * 创建博弈数据挖掘任务  
456 - * @tags 博弈数据挖掘模块  
457 - * @produces application/json  
458 - * @consumes application/json  
459 - */  
460 -export const postGamedataminingCreateMiningTask = /* #__PURE__ */ (() => {  
461 - const method = "post";  
462 - const url = "/gamedatamining/create-mining-task";  
463 - function request(  
464 - option: PostGamedataminingCreateMiningTaskOption  
465 - ): Promise<PostGamedataminingCreateMiningTaskResponseSuccess> {  
466 - return requester(request.url, {  
467 - method: request.method,  
468 - ...option,  
469 - }) as unknown as Promise<PostGamedataminingCreateMiningTaskResponseSuccess>;  
470 - }  
471 -  
472 - /** http method */  
473 - request.method = method;  
474 - /** request url */  
475 - request.url = url;  
476 - return request;  
477 -})();  
478 -  
479 -/** @description request parameter type for postGamedataminingCreateUploadTask */  
480 -export interface PostGamedataminingCreateUploadTaskOption {  
481 - /**  
482 - * @description  
483 - * 上传博弈数据  
484 - */  
485 - body: {  
486 - /**  
487 - @description  
488 - 上传博弈数据 */  
489 - request: ZFWJInternalPkgRequestCreateGdmUploadRequest;  
490 - };  
491 -}  
492 -  
493 -/** @description response type for postGamedataminingCreateUploadTask */  
494 -export interface PostGamedataminingCreateUploadTaskResponse {  
495 - /**  
496 - * @description  
497 - * OK  
498 - */  
499 - 200: ZFWJInternalPkgResponseResponse;  
500 -}  
501 -  
502 -export type PostGamedataminingCreateUploadTaskResponseSuccess =  
503 - PostGamedataminingCreateUploadTaskResponse[200];  
504 -/**  
505 - * @description  
506 - * 上传博弈数据  
507 - * @tags 博弈数据挖掘模块  
508 - * @produces application/json  
509 - * @consumes application/json  
510 - */  
511 -export const postGamedataminingCreateUploadTask = /* #__PURE__ */ (() => {  
512 - const method = "post";  
513 - const url = "/gamedatamining/create-upload-task";  
514 - function request(  
515 - option: PostGamedataminingCreateUploadTaskOption  
516 - ): Promise<PostGamedataminingCreateUploadTaskResponseSuccess> {  
517 - return requester(request.url, {  
518 - method: request.method,  
519 - ...option,  
520 - }) as unknown as Promise<PostGamedataminingCreateUploadTaskResponseSuccess>;  
521 - }  
522 -  
523 - /** http method */  
524 - request.method = method;  
525 - /** request url */  
526 - request.url = url;  
527 - return request;  
528 -})();  
529 -  
530 -/** @description request parameter type for getGamedataminingGameDataDetail */  
531 -export interface GetGamedataminingGameDataDetailOption {  
532 - /**  
533 - * @description  
534 - * 数据ID  
535 - */  
536 - query: {  
537 - /**  
538 - @description  
539 - 数据ID */  
540 - id: string;  
541 - };  
542 -}  
543 -  
544 -/** @description response type for getGamedataminingGameDataDetail */  
545 -export interface GetGamedataminingGameDataDetailResponse {  
546 - /**  
547 - * @description  
548 - * OK  
549 - */  
550 - 200: ZFWJInternalPkgResponseResponse;  
551 -}  
552 -  
553 -export type GetGamedataminingGameDataDetailResponseSuccess =  
554 - GetGamedataminingGameDataDetailResponse[200];  
555 -/**  
556 - * @description  
557 - * 获取博弈数据详情  
558 - * @tags 博弈数据挖掘模块  
559 - * @produces application/json  
560 - * @consumes application/json  
561 - */  
562 -export const getGamedataminingGameDataDetail = /* #__PURE__ */ (() => {  
563 - const method = "get";  
564 - const url = "/gamedatamining/game-data-detail";  
565 - function request(  
566 - option: GetGamedataminingGameDataDetailOption  
567 - ): Promise<GetGamedataminingGameDataDetailResponseSuccess> {  
568 - return requester(request.url, {  
569 - method: request.method,  
570 - ...option,  
571 - }) as unknown as Promise<GetGamedataminingGameDataDetailResponseSuccess>;  
572 - }  
573 -  
574 - /** http method */  
575 - request.method = method;  
576 - /** request url */  
577 - request.url = url;  
578 - return request;  
579 -})();  
580 -  
581 -/** @description request parameter type for putGamedataminingGameDataDetail */  
582 -export interface PutGamedataminingGameDataDetailOption {  
583 - /**  
584 - * @description  
585 - * 更新博弈数据  
586 - */  
587 - body: {  
588 - /**  
589 - @description  
590 - 更新博弈数据 */  
591 - request: ZFWJInternalPkgRequestUpdateGdmUploadRequest;  
592 - };  
593 -}  
594 -  
595 -/** @description response type for putGamedataminingGameDataDetail */  
596 -export interface PutGamedataminingGameDataDetailResponse {  
597 - /**  
598 - * @description  
599 - * OK  
600 - */  
601 - 200: ZFWJInternalPkgResponseResponse;  
602 -}  
603 -  
604 -export type PutGamedataminingGameDataDetailResponseSuccess =  
605 - PutGamedataminingGameDataDetailResponse[200];  
606 -/**  
607 - * @description  
608 - * 更新博弈数据  
609 - * @tags 博弈数据挖掘模块  
610 - * @produces application/json  
611 - * @consumes application/json  
612 - */  
613 -export const putGamedataminingGameDataDetail = /* #__PURE__ */ (() => {  
614 - const method = "put";  
615 - const url = "/gamedatamining/game-data-detail";  
616 - function request(  
617 - option: PutGamedataminingGameDataDetailOption  
618 - ): Promise<PutGamedataminingGameDataDetailResponseSuccess> {  
619 - return requester(request.url, {  
620 - method: request.method,  
621 - ...option,  
622 - }) as unknown as Promise<PutGamedataminingGameDataDetailResponseSuccess>;  
623 - }  
624 -  
625 - /** http method */  
626 - request.method = method;  
627 - /** request url */  
628 - request.url = url;  
629 - return request;  
630 -})();  
631 -  
632 -/** @description request parameter type for deleteGamedataminingGameDataDetail */  
633 -export interface DeleteGamedataminingGameDataDetailOption {  
634 - /**  
635 - * @description  
636 - * 数据ID  
637 - */  
638 - query: {  
639 - /**  
640 - @description  
641 - 数据ID */  
642 - Id: string;  
643 - };  
644 -}  
645 -  
646 -/** @description response type for deleteGamedataminingGameDataDetail */  
647 -export interface DeleteGamedataminingGameDataDetailResponse {  
648 - /**  
649 - * @description  
650 - * OK  
651 - */  
652 - 200: ZFWJInternalPkgResponseResponse;  
653 -}  
654 -  
655 -export type DeleteGamedataminingGameDataDetailResponseSuccess =  
656 - DeleteGamedataminingGameDataDetailResponse[200];  
657 -/**  
658 - * @description  
659 - * 删除博弈数据  
660 - * @tags 博弈数据挖掘模块  
661 - * @produces application/json  
662 - * @consumes application/json  
663 - */  
664 -export const deleteGamedataminingGameDataDetail = /* #__PURE__ */ (() => {  
665 - const method = "delete";  
666 - const url = "/gamedatamining/game-data-detail";  
667 - function request(  
668 - option: DeleteGamedataminingGameDataDetailOption  
669 - ): Promise<DeleteGamedataminingGameDataDetailResponseSuccess> {  
670 - return requester(request.url, {  
671 - method: request.method,  
672 - ...option,  
673 - }) as unknown as Promise<DeleteGamedataminingGameDataDetailResponseSuccess>;  
674 - }  
675 -  
676 - /** http method */  
677 - request.method = method;  
678 - /** request url */  
679 - request.url = url;  
680 - return request;  
681 -})();  
682 -  
683 -/** @description request parameter type for getGamedataminingGameDataList */  
684 -export interface GetGamedataminingGameDataListOption {  
685 - /**  
686 - * @description  
687 - * 页码  
688 - * @default 1  
689 - */  
690 - query: {  
691 - /**  
692 - @description  
693 - 页码  
694 - @default 1 */  
695 - PageNum: string;  
696 - /**  
697 - @description  
698 - 每页数量  
699 - @default 10 */  
700 - PageSize: string;  
701 - /**  
702 - @description  
703 - 任务名称 */  
704 - TaskName?: string;  
705 - };  
706 -}  
707 -  
708 -/** @description response type for getGamedataminingGameDataList */  
709 -export interface GetGamedataminingGameDataListResponse {  
710 - /**  
711 - * @description  
712 - * OK  
713 - */  
714 - 200: ZFWJInternalPkgResponseResponse;  
715 -}  
716 -  
717 -export type GetGamedataminingGameDataListResponseSuccess =  
718 - GetGamedataminingGameDataListResponse[200];  
719 -/**  
720 - * @description  
721 - * 支持分页  
722 - * 获取博弈数据列表  
723 - * @tags 博弈数据挖掘模块  
724 - * @produces application/json  
725 - * @consumes application/json  
726 - */  
727 -export const getGamedataminingGameDataList = /* #__PURE__ */ (() => {  
728 - const method = "get";  
729 - const url = "/gamedatamining/game-data-list";  
730 - function request(  
731 - option: GetGamedataminingGameDataListOption  
732 - ): Promise<GetGamedataminingGameDataListResponseSuccess> {  
733 - return requester(request.url, {  
734 - method: request.method,  
735 - ...option,  
736 - }) as unknown as Promise<GetGamedataminingGameDataListResponseSuccess>;  
737 - }  
738 -  
739 - /** http method */  
740 - request.method = method;  
741 - /** request url */  
742 - request.url = url;  
743 - return request;  
744 -})();  
745 -  
746 -/** @description request parameter type for getGamedataminingMiningResultDetail */  
747 -export interface GetGamedataminingMiningResultDetailOption {  
748 - /**  
749 - * @description  
750 - * 结果ID  
751 - */  
752 - query: {  
753 - /**  
754 - @description  
755 - 结果ID */  
756 - Id: string;  
757 - };  
758 -}  
759 -  
760 -/** @description response type for getGamedataminingMiningResultDetail */  
761 -export interface GetGamedataminingMiningResultDetailResponse {  
762 - /**  
763 - * @description  
764 - * OK  
765 - */  
766 - 200: ZFWJInternalPkgResponseResponse;  
767 -}  
768 -  
769 -export type GetGamedataminingMiningResultDetailResponseSuccess =  
770 - GetGamedataminingMiningResultDetailResponse[200];  
771 -/**  
772 - * @description  
773 - * 获取博弈数据挖掘结果详情  
774 - * @tags 博弈数据挖掘模块  
775 - * @produces application/json  
776 - * @consumes application/json  
777 - */  
778 -export const getGamedataminingMiningResultDetail = /* #__PURE__ */ (() => {  
779 - const method = "get";  
780 - const url = "/gamedatamining/mining-result-detail";  
781 - function request(  
782 - option: GetGamedataminingMiningResultDetailOption  
783 - ): Promise<GetGamedataminingMiningResultDetailResponseSuccess> {  
784 - return requester(request.url, {  
785 - method: request.method,  
786 - ...option,  
787 - }) as unknown as Promise<GetGamedataminingMiningResultDetailResponseSuccess>;  
788 - }  
789 -  
790 - /** http method */  
791 - request.method = method;  
792 - /** request url */  
793 - request.url = url;  
794 - return request;  
795 -})();  
796 -  
797 -/** @description request parameter type for putGamedataminingMiningResultDetail */  
798 -export interface PutGamedataminingMiningResultDetailOption {  
799 - /**  
800 - * @description  
801 - * 更新博弈数据挖掘结果  
802 - */  
803 - body: {  
804 - /**  
805 - @description  
806 - 更新博弈数据挖掘结果 */  
807 - request: ZFWJInternalPkgRequestUpdateGameDataMiningResultRequest;  
808 - };  
809 -}  
810 -  
811 -/** @description response type for putGamedataminingMiningResultDetail */  
812 -export interface PutGamedataminingMiningResultDetailResponse {  
813 - /**  
814 - * @description  
815 - * OK  
816 - */  
817 - 200: ZFWJInternalPkgResponseResponse;  
818 -}  
819 -  
820 -export type PutGamedataminingMiningResultDetailResponseSuccess =  
821 - PutGamedataminingMiningResultDetailResponse[200];  
822 -/**  
823 - * @description  
824 - * 更新博弈数据挖掘结果  
825 - * @tags 博弈数据挖掘模块  
826 - * @produces application/json  
827 - * @consumes application/json  
828 - */  
829 -export const putGamedataminingMiningResultDetail = /* #__PURE__ */ (() => {  
830 - const method = "put";  
831 - const url = "/gamedatamining/mining-result-detail";  
832 - function request(  
833 - option: PutGamedataminingMiningResultDetailOption  
834 - ): Promise<PutGamedataminingMiningResultDetailResponseSuccess> {  
835 - return requester(request.url, {  
836 - method: request.method,  
837 - ...option,  
838 - }) as unknown as Promise<PutGamedataminingMiningResultDetailResponseSuccess>;  
839 - }  
840 -  
841 - /** http method */  
842 - request.method = method;  
843 - /** request url */  
844 - request.url = url;  
845 - return request;  
846 -})();  
847 -  
848 -/** @description request parameter type for getGamedataminingMiningResultList */  
849 -export interface GetGamedataminingMiningResultListOption {  
850 - /**  
851 - * @description  
852 - * 任务ID  
853 - */  
854 - query: {  
855 - /**  
856 - @description  
857 - 任务ID */  
858 - TaskId: string;  
859 - };  
860 -}  
861 -  
862 -/** @description response type for getGamedataminingMiningResultList */  
863 -export interface GetGamedataminingMiningResultListResponse {  
864 - /**  
865 - * @description  
866 - * OK  
867 - */  
868 - 200: ZFWJInternalPkgResponseResponse;  
869 -}  
870 -  
871 -export type GetGamedataminingMiningResultListResponseSuccess =  
872 - GetGamedataminingMiningResultListResponse[200];  
873 -/**  
874 - * @description  
875 - * 获取博弈数据挖掘结果列表  
876 - * @tags 博弈数据挖掘模块  
877 - * @produces application/json  
878 - * @consumes application/json  
879 - */  
880 -export const getGamedataminingMiningResultList = /* #__PURE__ */ (() => {  
881 - const method = "get";  
882 - const url = "/gamedatamining/mining-result-list";  
883 - function request(  
884 - option: GetGamedataminingMiningResultListOption  
885 - ): Promise<GetGamedataminingMiningResultListResponseSuccess> {  
886 - return requester(request.url, {  
887 - method: request.method,  
888 - ...option,  
889 - }) as unknown as Promise<GetGamedataminingMiningResultListResponseSuccess>;  
890 - }  
891 -  
892 - /** http method */  
893 - request.method = method;  
894 - /** request url */  
895 - request.url = url;  
896 - return request;  
897 -})();  
898 -  
899 -/** @description request parameter type for deleteGamedataminingMiningTask */  
900 -export interface DeleteGamedataminingMiningTaskOption {  
901 - /**  
902 - * @description  
903 - * 任务ID  
904 - */  
905 - query: {  
906 - /**  
907 - @description  
908 - 任务ID */  
909 - TaskId: string;  
910 - };  
911 -}  
912 -  
913 -/** @description response type for deleteGamedataminingMiningTask */  
914 -export interface DeleteGamedataminingMiningTaskResponse {  
915 - /**  
916 - * @description  
917 - * OK  
918 - */  
919 - 200: ZFWJInternalPkgResponseResponse;  
920 -}  
921 -  
922 -export type DeleteGamedataminingMiningTaskResponseSuccess =  
923 - DeleteGamedataminingMiningTaskResponse[200];  
924 -/**  
925 - * @description  
926 - * 删除博弈数据挖掘任务  
927 - * @tags 博弈数据挖掘模块  
928 - * @produces application/json  
929 - * @consumes application/json  
930 - */  
931 -export const deleteGamedataminingMiningTask = /* #__PURE__ */ (() => {  
932 - const method = "delete";  
933 - const url = "/gamedatamining/mining-task";  
934 - function request(  
935 - option: DeleteGamedataminingMiningTaskOption  
936 - ): Promise<DeleteGamedataminingMiningTaskResponseSuccess> {  
937 - return requester(request.url, {  
938 - method: request.method,  
939 - ...option,  
940 - }) as unknown as Promise<DeleteGamedataminingMiningTaskResponseSuccess>;  
941 - }  
942 -  
943 - /** http method */  
944 - request.method = method;  
945 - /** request url */  
946 - request.url = url;  
947 - return request;  
948 -})();  
949 -  
950 -/** @description request parameter type for getGamedataminingMiningTaskDetail */  
951 -export interface GetGamedataminingMiningTaskDetailOption {  
952 - /**  
953 - * @description  
954 - * 任务ID  
955 - */  
956 - query: {  
957 - /**  
958 - @description  
959 - 任务ID */  
960 - id: string;  
961 - };  
962 -}  
963 -  
964 -/** @description response type for getGamedataminingMiningTaskDetail */  
965 -export interface GetGamedataminingMiningTaskDetailResponse {  
966 - /**  
967 - * @description  
968 - * OK  
969 - */  
970 - 200: ZFWJInternalPkgResponseResponse;  
971 -}  
972 -  
973 -export type GetGamedataminingMiningTaskDetailResponseSuccess =  
974 - GetGamedataminingMiningTaskDetailResponse[200];  
975 -/**  
976 - * @description  
977 - * 获取博弈数据挖掘任务详情  
978 - * @tags 博弈数据挖掘模块  
979 - * @produces application/json  
980 - * @consumes application/json  
981 - */  
982 -export const getGamedataminingMiningTaskDetail = /* #__PURE__ */ (() => {  
983 - const method = "get";  
984 - const url = "/gamedatamining/mining-task-detail";  
985 - function request(  
986 - option: GetGamedataminingMiningTaskDetailOption  
987 - ): Promise<GetGamedataminingMiningTaskDetailResponseSuccess> {  
988 - return requester(request.url, {  
989 - method: request.method,  
990 - ...option,  
991 - }) as unknown as Promise<GetGamedataminingMiningTaskDetailResponseSuccess>;  
992 - }  
993 -  
994 - /** http method */  
995 - request.method = method;  
996 - /** request url */  
997 - request.url = url;  
998 - return request;  
999 -})();  
1000 -  
1001 -/** @description request parameter type for getGamedataminingMiningTaskList */  
1002 -export interface GetGamedataminingMiningTaskListOption {  
1003 - /**  
1004 - * @description  
1005 - * 页码  
1006 - * @default 1  
1007 - */  
1008 - query: {  
1009 - /**  
1010 - @description  
1011 - 页码  
1012 - @default 1 */  
1013 - PageNum: string;  
1014 - /**  
1015 - @description  
1016 - 每页数量  
1017 - @default 10 */  
1018 - PageSize: string;  
1019 - /**  
1020 - @description  
1021 - 任务名称 */  
1022 - TaskName?: string;  
1023 - };  
1024 -}  
1025 -  
1026 -/** @description response type for getGamedataminingMiningTaskList */  
1027 -export interface GetGamedataminingMiningTaskListResponse {  
1028 - /**  
1029 - * @description  
1030 - * OK  
1031 - */  
1032 - 200: ZFWJInternalPkgResponseResponse;  
1033 -}  
1034 -  
1035 -export type GetGamedataminingMiningTaskListResponseSuccess =  
1036 - GetGamedataminingMiningTaskListResponse[200];  
1037 -/**  
1038 - * @description  
1039 - * 支持分页  
1040 - * 获取博弈数据挖掘任务列表  
1041 - * @tags 博弈数据挖掘模块  
1042 - * @produces application/json  
1043 - * @consumes application/json  
1044 - */  
1045 -export const getGamedataminingMiningTaskList = /* #__PURE__ */ (() => {  
1046 - const method = "get";  
1047 - const url = "/gamedatamining/mining-task-list";  
1048 - function request(  
1049 - option: GetGamedataminingMiningTaskListOption  
1050 - ): Promise<GetGamedataminingMiningTaskListResponseSuccess> {  
1051 - return requester(request.url, {  
1052 - method: request.method,  
1053 - ...option,  
1054 - }) as unknown as Promise<GetGamedataminingMiningTaskListResponseSuccess>;  
1055 - }  
1056 -  
1057 - /** http method */  
1058 - request.method = method;  
1059 - /** request url */  
1060 - request.url = url;  
1061 - return request;  
1062 -})();  
1063 -  
1064 -/** @description request parameter type for putGamedataminingOpenTask */  
1065 -export interface PutGamedataminingOpenTaskOption {  
1066 - /**  
1067 - * @description  
1068 - * taskID  
1069 - */  
1070 - body: {  
1071 - /**  
1072 - @description  
1073 - taskID */  
1074 - request: ZFWJInternalPkgRequestOpenTaskRequest;  
1075 - };  
1076 -}  
1077 -  
1078 -/** @description response type for putGamedataminingOpenTask */  
1079 -export interface PutGamedataminingOpenTaskResponse {  
1080 - /**  
1081 - * @description  
1082 - * OK  
1083 - */  
1084 - 200: ZFWJInternalPkgResponseResponse;  
1085 -}  
1086 -  
1087 -export type PutGamedataminingOpenTaskResponseSuccess =  
1088 - PutGamedataminingOpenTaskResponse[200];  
1089 -/**  
1090 - * @description  
1091 - * 开启博弈数据挖掘任务  
1092 - * @tags 博弈数据挖掘模块  
1093 - * @produces application/json  
1094 - * @consumes application/json  
1095 - */  
1096 -export const putGamedataminingOpenTask = /* #__PURE__ */ (() => {  
1097 - const method = "put";  
1098 - const url = "/gamedatamining/open-task";  
1099 - function request(  
1100 - option: PutGamedataminingOpenTaskOption  
1101 - ): Promise<PutGamedataminingOpenTaskResponseSuccess> {  
1102 - return requester(request.url, {  
1103 - method: request.method,  
1104 - ...option,  
1105 - }) as unknown as Promise<PutGamedataminingOpenTaskResponseSuccess>;  
1106 - }  
1107 -  
1108 - /** http method */  
1109 - request.method = method;  
1110 - /** request url */  
1111 - request.url = url;  
1112 - return request;  
1113 -})();  
1114 -  
1115 -/** @description request parameter type for getGamedataminingOrganizeResultList */  
1116 -export interface GetGamedataminingOrganizeResultListOption {  
1117 - /**  
1118 - * @description  
1119 - * 页码  
1120 - * @default 1  
1121 - */  
1122 - query: {  
1123 - /**  
1124 - @description  
1125 - 页码  
1126 - @default 1 */  
1127 - PageNum: string;  
1128 - /**  
1129 - @description  
1130 - 每页数量  
1131 - @default 10 */  
1132 - PageSize: string;  
1133 - /**  
1134 - @description  
1135 - 任务ID */  
1136 - TaskId?: string;  
1137 - };  
1138 -}  
1139 -  
1140 -/** @description response type for getGamedataminingOrganizeResultList */  
1141 -export interface GetGamedataminingOrganizeResultListResponse {  
1142 - /**  
1143 - * @description  
1144 - * OK  
1145 - */  
1146 - 200: ZFWJInternalPkgResponseResponse;  
1147 -}  
1148 -  
1149 -export type GetGamedataminingOrganizeResultListResponseSuccess =  
1150 - GetGamedataminingOrganizeResultListResponse[200];  
1151 -/**  
1152 - * @description  
1153 - * 支持分页  
1154 - * 获取整编结果列表  
1155 - * @tags 博弈数据挖掘模块  
1156 - * @produces application/json  
1157 - * @consumes application/json  
1158 - */  
1159 -export const getGamedataminingOrganizeResultList = /* #__PURE__ */ (() => {  
1160 - const method = "get";  
1161 - const url = "/gamedatamining/organize-result-list";  
1162 - function request(  
1163 - option: GetGamedataminingOrganizeResultListOption  
1164 - ): Promise<GetGamedataminingOrganizeResultListResponseSuccess> {  
1165 - return requester(request.url, {  
1166 - method: request.method,  
1167 - ...option,  
1168 - }) as unknown as Promise<GetGamedataminingOrganizeResultListResponseSuccess>;  
1169 - }  
1170 -  
1171 - /** http method */  
1172 - request.method = method;  
1173 - /** request url */  
1174 - request.url = url;  
1175 - return request;  
1176 -})();  
1177 -  
1178 -/** @description request parameter type for putGamedataminingOrganizeResultSlice */  
1179 -export interface PutGamedataminingOrganizeResultSliceOption {  
1180 - /**  
1181 - * @description  
1182 - * 更新整编结果切片  
1183 - */  
1184 - body: {  
1185 - /**  
1186 - @description  
1187 - 更新整编结果切片 */  
1188 - request: ZFWJInternalPkgRequestUpdateOrsRequest;  
1189 - };  
1190 -}  
1191 -  
1192 -/** @description response type for putGamedataminingOrganizeResultSlice */  
1193 -export interface PutGamedataminingOrganizeResultSliceResponse {  
1194 - /**  
1195 - * @description  
1196 - * OK  
1197 - */  
1198 - 200: ZFWJInternalPkgResponseResponse;  
1199 -}  
1200 -  
1201 -export type PutGamedataminingOrganizeResultSliceResponseSuccess =  
1202 - PutGamedataminingOrganizeResultSliceResponse[200];  
1203 -/**  
1204 - * @description  
1205 - * 更新整编结果切片  
1206 - * @tags 博弈数据挖掘模块  
1207 - * @produces application/json  
1208 - * @consumes application/json  
1209 - */  
1210 -export const putGamedataminingOrganizeResultSlice = /* #__PURE__ */ (() => {  
1211 - const method = "put";  
1212 - const url = "/gamedatamining/organize-result-slice";  
1213 - function request(  
1214 - option: PutGamedataminingOrganizeResultSliceOption  
1215 - ): Promise<PutGamedataminingOrganizeResultSliceResponseSuccess> {  
1216 - return requester(request.url, {  
1217 - method: request.method,  
1218 - ...option,  
1219 - }) as unknown as Promise<PutGamedataminingOrganizeResultSliceResponseSuccess>;  
1220 - }  
1221 -  
1222 - /** http method */  
1223 - request.method = method;  
1224 - /** request url */  
1225 - request.url = url;  
1226 - return request;  
1227 -})();  
1228 -  
1229 -/** @description request parameter type for postGamedataminingOrganizeResultSlice */  
1230 -export interface PostGamedataminingOrganizeResultSliceOption {  
1231 - /**  
1232 - * @description  
1233 - * 创建整编结果切片  
1234 - */  
1235 - body: {  
1236 - /**  
1237 - @description  
1238 - 创建整编结果切片 */  
1239 - request: ZFWJInternalPkgRequestCreateOrsRequest;  
1240 - };  
1241 -}  
1242 -  
1243 -/** @description response type for postGamedataminingOrganizeResultSlice */  
1244 -export interface PostGamedataminingOrganizeResultSliceResponse {  
1245 - /**  
1246 - * @description  
1247 - * OK  
1248 - */  
1249 - 200: ZFWJInternalPkgResponseResponse;  
1250 -}  
1251 -  
1252 -export type PostGamedataminingOrganizeResultSliceResponseSuccess =  
1253 - PostGamedataminingOrganizeResultSliceResponse[200];  
1254 -/**  
1255 - * @description  
1256 - * 创建整编结果切片  
1257 - * @tags 博弈数据挖掘模块  
1258 - * @produces application/json  
1259 - * @consumes application/json  
1260 - */  
1261 -export const postGamedataminingOrganizeResultSlice = /* #__PURE__ */ (() => {  
1262 - const method = "post";  
1263 - const url = "/gamedatamining/organize-result-slice";  
1264 - function request(  
1265 - option: PostGamedataminingOrganizeResultSliceOption  
1266 - ): Promise<PostGamedataminingOrganizeResultSliceResponseSuccess> {  
1267 - return requester(request.url, {  
1268 - method: request.method,  
1269 - ...option,  
1270 - }) as unknown as Promise<PostGamedataminingOrganizeResultSliceResponseSuccess>;  
1271 - }  
1272 -  
1273 - /** http method */  
1274 - request.method = method;  
1275 - /** request url */  
1276 - request.url = url;  
1277 - return request;  
1278 -})();  
1279 -  
1280 -/** @description request parameter type for deleteGamedataminingOrganizeResultSlice */  
1281 -export interface DeleteGamedataminingOrganizeResultSliceOption {  
1282 - /**  
1283 - * @description  
1284 - * 切片ID  
1285 - */  
1286 - query: {  
1287 - /**  
1288 - @description  
1289 - 切片ID */  
1290 - SliceId: string;  
1291 - };  
1292 -}  
1293 -  
1294 -/** @description response type for deleteGamedataminingOrganizeResultSlice */  
1295 -export interface DeleteGamedataminingOrganizeResultSliceResponse {  
1296 - /**  
1297 - * @description  
1298 - * OK  
1299 - */  
1300 - 200: ZFWJInternalPkgResponseResponse;  
1301 -}  
1302 -  
1303 -export type DeleteGamedataminingOrganizeResultSliceResponseSuccess =  
1304 - DeleteGamedataminingOrganizeResultSliceResponse[200];  
1305 -/**  
1306 - * @description  
1307 - * 删除整编结果切片  
1308 - * @tags 博弈数据挖掘模块  
1309 - * @produces application/json  
1310 - * @consumes application/json  
1311 - */  
1312 -export const deleteGamedataminingOrganizeResultSlice = /* #__PURE__ */ (() => {  
1313 - const method = "delete";  
1314 - const url = "/gamedatamining/organize-result-slice";  
1315 - function request(  
1316 - option: DeleteGamedataminingOrganizeResultSliceOption  
1317 - ): Promise<DeleteGamedataminingOrganizeResultSliceResponseSuccess> {  
1318 - return requester(request.url, {  
1319 - method: request.method,  
1320 - ...option,  
1321 - }) as unknown as Promise<DeleteGamedataminingOrganizeResultSliceResponseSuccess>;  
1322 - }  
1323 -  
1324 - /** http method */  
1325 - request.method = method;  
1326 - /** request url */  
1327 - request.url = url;  
1328 - return request;  
1329 -})();  
1330 -  
1331 -/** @description request parameter type for getGamedataminingOrganizeResultSlices */  
1332 -export interface GetGamedataminingOrganizeResultSlicesOption {  
1333 - /**  
1334 - * @description  
1335 - * 文件ID  
1336 - */  
1337 - query: {  
1338 - /**  
1339 - @description  
1340 - 文件ID */  
1341 - id: string;  
1342 - };  
1343 -}  
1344 -  
1345 -/** @description response type for getGamedataminingOrganizeResultSlices */  
1346 -export interface GetGamedataminingOrganizeResultSlicesResponse {  
1347 - /**  
1348 - * @description  
1349 - * OK  
1350 - */  
1351 - 200: ZFWJInternalPkgResponseResponse;  
1352 -}  
1353 -  
1354 -export type GetGamedataminingOrganizeResultSlicesResponseSuccess =  
1355 - GetGamedataminingOrganizeResultSlicesResponse[200];  
1356 -/**  
1357 - * @description  
1358 - * 获取整编结果切片列表  
1359 - * @tags 博弈数据挖掘模块  
1360 - * @produces application/json  
1361 - * @consumes application/json  
1362 - */  
1363 -export const getGamedataminingOrganizeResultSlices = /* #__PURE__ */ (() => {  
1364 - const method = "get";  
1365 - const url = "/gamedatamining/organize-result-slices";  
1366 - function request(  
1367 - option: GetGamedataminingOrganizeResultSlicesOption  
1368 - ): Promise<GetGamedataminingOrganizeResultSlicesResponseSuccess> {  
1369 - return requester(request.url, {  
1370 - method: request.method,  
1371 - ...option,  
1372 - }) as unknown as Promise<GetGamedataminingOrganizeResultSlicesResponseSuccess>;  
1373 - }  
1374 -  
1375 - /** http method */  
1376 - request.method = method;  
1377 - /** request url */  
1378 - request.url = url;  
1379 - return request;  
1380 -})();  
1381 -  
1382 -/** @description request parameter type for getKnowledgegraph */  
1383 -export interface GetKnowledgegraphOption {  
1384 - /**  
1385 - * @description  
1386 - * 节点ID  
1387 - */  
1388 - query: {  
1389 - /**  
1390 - @description  
1391 - 节点ID */  
1392 - NodeId: number;  
1393 - /**  
1394 - @description  
1395 - 任务ID */  
1396 - TaskId: string;  
1397 - };  
1398 -}  
1399 -  
1400 -/** @description response type for getKnowledgegraph */  
1401 -export interface GetKnowledgegraphResponse {  
1402 - /**  
1403 - * @description  
1404 - * OK  
1405 - */  
1406 - 200: ZFWJInternalPkgResponseResponse;  
1407 -}  
1408 -  
1409 -export type GetKnowledgegraphResponseSuccess = GetKnowledgegraphResponse[200];  
1410 -/**  
1411 - * @description  
1412 - * 根据Node获取图谱数据  
1413 - * @tags 知识库模块  
1414 - * @produces application/json  
1415 - * @consumes application/json  
1416 - */  
1417 -export const getKnowledgegraph = /* #__PURE__ */ (() => {  
1418 - const method = "get";  
1419 - const url = "/knowledgegraph";  
1420 - function request(  
1421 - option: GetKnowledgegraphOption  
1422 - ): Promise<GetKnowledgegraphResponseSuccess> {  
1423 - return requester(request.url, {  
1424 - method: request.method,  
1425 - ...option,  
1426 - }) as unknown as Promise<GetKnowledgegraphResponseSuccess>;  
1427 - }  
1428 -  
1429 - /** http method */  
1430 - request.method = method;  
1431 - /** request url */  
1432 - request.url = url;  
1433 - return request;  
1434 -})();  
1435 -  
1436 -/** @description request parameter type for getKnowledgegraphAdvance */  
1437 -export interface GetKnowledgegraphAdvanceOption {  
1438 - /**  
1439 - * @description  
1440 - * 国家  
1441 - */  
1442 - query: {  
1443 - /**  
1444 - @description  
1445 - 国家 */  
1446 - Country: string;  
1447 - /**  
1448 - @description  
1449 - 大类 */  
1450 - BigType: string;  
1451 - /**  
1452 - @description  
1453 - 类型 */  
1454 - Type: string;  
1455 - /**  
1456 - @description  
1457 - 任务ID */  
1458 - TaskId: string;  
1459 - /**  
1460 - @description  
1461 - 文本类型 */  
1462 - TextType: string;  
1463 - };  
1464 -}  
1465 -  
1466 -/** @description response type for getKnowledgegraphAdvance */  
1467 -export interface GetKnowledgegraphAdvanceResponse {  
1468 - /**  
1469 - * @description  
1470 - * OK  
1471 - */  
1472 - 200: ZFWJInternalPkgResponseResponse;  
1473 -}  
1474 -  
1475 -export type GetKnowledgegraphAdvanceResponseSuccess =  
1476 - GetKnowledgegraphAdvanceResponse[200];  
1477 -/**  
1478 - * @description  
1479 - * 高级搜索  
1480 - * @tags 知识库模块  
1481 - * @produces application/json  
1482 - * @consumes application/json  
1483 - */  
1484 -export const getKnowledgegraphAdvance = /* #__PURE__ */ (() => {  
1485 - const method = "get";  
1486 - const url = "/knowledgegraph/advance";  
1487 - function request(  
1488 - option: GetKnowledgegraphAdvanceOption  
1489 - ): Promise<GetKnowledgegraphAdvanceResponseSuccess> {  
1490 - return requester(request.url, {  
1491 - method: request.method,  
1492 - ...option,  
1493 - }) as unknown as Promise<GetKnowledgegraphAdvanceResponseSuccess>;  
1494 - }  
1495 -  
1496 - /** http method */  
1497 - request.method = method;  
1498 - /** request url */  
1499 - request.url = url;  
1500 - return request;  
1501 -})();  
1502 -  
1503 -/** @description request parameter type for getKnowledgegraphInit */  
1504 -export interface GetKnowledgegraphInitOption {  
1505 - /**  
1506 - * @description  
1507 - * 任务ID  
1508 - */  
1509 - query: {  
1510 - /**  
1511 - @description  
1512 - 任务ID */  
1513 - TaskId: string;  
1514 - /**  
1515 - @description  
1516 - 文本类型 */  
1517 - TextType: string;  
1518 - /**  
1519 - @description  
1520 - 层数 */  
1521 - Storey: number;  
1522 - };  
1523 -}  
1524 -  
1525 -/** @description response type for getKnowledgegraphInit */  
1526 -export interface GetKnowledgegraphInitResponse {  
1527 - /**  
1528 - * @description  
1529 - * OK  
1530 - */  
1531 - 200: ZFWJInternalPkgResponseResponse;  
1532 -}  
1533 -  
1534 -export type GetKnowledgegraphInitResponseSuccess =  
1535 - GetKnowledgegraphInitResponse[200];  
1536 -/**  
1537 - * @description  
1538 - * 获取初始图谱数据  
1539 - * @tags 知识库模块  
1540 - * @produces application/json  
1541 - * @consumes application/json  
1542 - */  
1543 -export const getKnowledgegraphInit = /* #__PURE__ */ (() => {  
1544 - const method = "get";  
1545 - const url = "/knowledgegraph/init";  
1546 - function request(  
1547 - option: GetKnowledgegraphInitOption  
1548 - ): Promise<GetKnowledgegraphInitResponseSuccess> {  
1549 - return requester(request.url, {  
1550 - method: request.method,  
1551 - ...option,  
1552 - }) as unknown as Promise<GetKnowledgegraphInitResponseSuccess>;  
1553 - }  
1554 -  
1555 - /** http method */  
1556 - request.method = method;  
1557 - /** request url */  
1558 - request.url = url;  
1559 - return request;  
1560 -})();  
1561 -  
1562 -/** @description request parameter type for getKnowledgegraphKeyword */  
1563 -export interface GetKnowledgegraphKeywordOption {  
1564 - /**  
1565 - * @description  
1566 - * 关键词  
1567 - */  
1568 - query: {  
1569 - /**  
1570 - @description  
1571 - 关键词 */  
1572 - Keyword: string;  
1573 - /**  
1574 - @description  
1575 - 文本类型 */  
1576 - TextType: string;  
1577 - /**  
1578 - @description  
1579 - 任务ID */  
1580 - TaskId: string;  
1581 - };  
1582 -}  
1583 -  
1584 -/** @description response type for getKnowledgegraphKeyword */  
1585 -export interface GetKnowledgegraphKeywordResponse {  
1586 - /**  
1587 - * @description  
1588 - * OK  
1589 - */  
1590 - 200: ZFWJInternalPkgResponseResponse;  
1591 -}  
1592 -  
1593 -export type GetKnowledgegraphKeywordResponseSuccess =  
1594 - GetKnowledgegraphKeywordResponse[200];  
1595 -/**  
1596 - * @description  
1597 - * 根据关键词搜索  
1598 - * @tags 知识库模块  
1599 - * @produces application/json  
1600 - * @consumes application/json  
1601 - */  
1602 -export const getKnowledgegraphKeyword = /* #__PURE__ */ (() => {  
1603 - const method = "get";  
1604 - const url = "/knowledgegraph/keyword";  
1605 - function request(  
1606 - option: GetKnowledgegraphKeywordOption  
1607 - ): Promise<GetKnowledgegraphKeywordResponseSuccess> {  
1608 - return requester(request.url, {  
1609 - method: request.method,  
1610 - ...option,  
1611 - }) as unknown as Promise<GetKnowledgegraphKeywordResponseSuccess>;  
1612 - }  
1613 -  
1614 - /** http method */  
1615 - request.method = method;  
1616 - /** request url */  
1617 - request.url = url;  
1618 - return request;  
1619 -})();  
1620 -  
1621 -/** @description request parameter type for getKnowledgegraphLabels */  
1622 -export interface GetKnowledgegraphLabelsOption {  
1623 - /**  
1624 - * @description  
1625 - * 任务ID  
1626 - */  
1627 - query: {  
1628 - /**  
1629 - @description  
1630 - 任务ID */  
1631 - TaskId: string;  
1632 - };  
1633 -}  
1634 -  
1635 -/** @description response type for getKnowledgegraphLabels */  
1636 -export interface GetKnowledgegraphLabelsResponse {  
1637 - /**  
1638 - * @description  
1639 - * OK  
1640 - */  
1641 - 200: ZFWJInternalPkgResponseResponse;  
1642 -}  
1643 -  
1644 -export type GetKnowledgegraphLabelsResponseSuccess =  
1645 - GetKnowledgegraphLabelsResponse[200];  
1646 -/**  
1647 - * @description  
1648 - * 获取标签数据  
1649 - * @tags 知识库模块  
1650 - * @produces application/json  
1651 - * @consumes application/json  
1652 - */  
1653 -export const getKnowledgegraphLabels = /* #__PURE__ */ (() => {  
1654 - const method = "get";  
1655 - const url = "/knowledgegraph/labels";  
1656 - function request(  
1657 - option: GetKnowledgegraphLabelsOption  
1658 - ): Promise<GetKnowledgegraphLabelsResponseSuccess> {  
1659 - return requester(request.url, {  
1660 - method: request.method,  
1661 - ...option,  
1662 - }) as unknown as Promise<GetKnowledgegraphLabelsResponseSuccess>;  
1663 - }  
1664 -  
1665 - /** http method */  
1666 - request.method = method;  
1667 - /** request url */  
1668 - request.url = url;  
1669 - return request;  
1670 -})();  
1671 -  
1672 -/** @description request parameter type for postLogin */  
1673 -export interface PostLoginOption {  
1674 - /**  
1675 - * @description  
1676 - * params  
1677 - */  
1678 - body: {  
1679 - /**  
1680 - @description  
1681 - params */  
1682 - request: ZFWJInternalPkgRequestLoginRequest;  
1683 - };  
1684 -}  
1685 -  
1686 -/** @description response type for postLogin */  
1687 -export interface PostLoginResponse {  
1688 - /**  
1689 - * @description  
1690 - * OK  
1691 - */  
1692 - 200: ZFWJInternalPkgResponseResponse;  
1693 -}  
1694 -  
1695 -export type PostLoginResponseSuccess = PostLoginResponse[200];  
1696 -/**  
1697 - * @description  
1698 - * 账号登录  
1699 - * @tags 用户模块  
1700 - * @produces application/json  
1701 - * @consumes application/json  
1702 - */  
1703 -export const postLogin = /* #__PURE__ */ (() => {  
1704 - const method = "post";  
1705 - const url = "/login";  
1706 - function request(option: PostLoginOption): Promise<PostLoginResponseSuccess> {  
1707 - return requester(request.url, {  
1708 - method: request.method,  
1709 - ...option,  
1710 - }) as unknown as Promise<PostLoginResponseSuccess>;  
1711 - }  
1712 -  
1713 - /** http method */  
1714 - request.method = method;  
1715 - /** request url */  
1716 - request.url = url;  
1717 - return request;  
1718 -})();  
1719 -  
1720 -/** @description request parameter type for postRegister */  
1721 -export interface PostRegisterOption {  
1722 - /**  
1723 - * @description  
1724 - * params  
1725 - */  
1726 - body: {  
1727 - /**  
1728 - @description  
1729 - params */  
1730 - request: ZFWJInternalPkgRequestRegisterRequest;  
1731 - };  
1732 -}  
1733 -  
1734 -/** @description response type for postRegister */  
1735 -export interface PostRegisterResponse {  
1736 - /**  
1737 - * @description  
1738 - * OK  
1739 - */  
1740 - 200: ZFWJInternalPkgResponseResponse;  
1741 -}  
1742 -  
1743 -export type PostRegisterResponseSuccess = PostRegisterResponse[200];  
1744 -/**  
1745 - * @description  
1746 - * 用户注册  
1747 - * @tags 用户模块  
1748 - * @produces application/json  
1749 - * @consumes application/json  
1750 - */  
1751 -export const postRegister = /* #__PURE__ */ (() => {  
1752 - const method = "post";  
1753 - const url = "/register";  
1754 - function request(  
1755 - option: PostRegisterOption  
1756 - ): Promise<PostRegisterResponseSuccess> {  
1757 - return requester(request.url, {  
1758 - method: request.method,  
1759 - ...option,  
1760 - }) as unknown as Promise<PostRegisterResponseSuccess>;  
1761 - }  
1762 -  
1763 - /** http method */  
1764 - request.method = method;  
1765 - /** request url */  
1766 - request.url = url;  
1767 - return request;  
1768 -})();  
1769 -  
1770 -/** @description request parameter type for getStrategyrule */  
1771 -export interface GetStrategyruleOption {  
1772 - /**  
1773 - * @description  
1774 - * Id  
1775 - */  
1776 - query: {  
1777 - /**  
1778 - @description  
1779 - Id */  
1780 - Id: string;  
1781 - };  
1782 -}  
1783 -  
1784 -/** @description response type for getStrategyrule */  
1785 -export interface GetStrategyruleResponse {  
1786 - /**  
1787 - * @description  
1788 - * OK  
1789 - */  
1790 - 200: ZFWJInternalPkgResponseResponse;  
1791 -}  
1792 -  
1793 -export type GetStrategyruleResponseSuccess = GetStrategyruleResponse[200];  
1794 -/**  
1795 - * @description  
1796 - * 获取战法规则  
1797 - * 获取战法规则  
1798 - * @tags 战法规则库  
1799 - * @produces application/json  
1800 - * @consumes application/json  
1801 - */  
1802 -export const getStrategyrule = /* #__PURE__ */ (() => {  
1803 - const method = "get";  
1804 - const url = "/strategyrule";  
1805 - function request(  
1806 - option: GetStrategyruleOption  
1807 - ): Promise<GetStrategyruleResponseSuccess> {  
1808 - return requester(request.url, {  
1809 - method: request.method,  
1810 - ...option,  
1811 - }) as unknown as Promise<GetStrategyruleResponseSuccess>;  
1812 - }  
1813 -  
1814 - /** http method */  
1815 - request.method = method;  
1816 - /** request url */  
1817 - request.url = url;  
1818 - return request;  
1819 -})();  
1820 -  
1821 -/** @description request parameter type for putStrategyrule */  
1822 -export interface PutStrategyruleOption {  
1823 - /**  
1824 - * @description  
1825 - * 战法规则信息  
1826 - */  
1827 - body: {  
1828 - /**  
1829 - @description  
1830 - 战法规则信息 */  
1831 - request: ZFWJInternalPkgRequestUpdateStrategyRuleRequest;  
1832 - };  
1833 -}  
1834 -  
1835 -/** @description response type for putStrategyrule */  
1836 -export interface PutStrategyruleResponse {  
1837 - /**  
1838 - * @description  
1839 - * OK  
1840 - */  
1841 - 200: ZFWJInternalPkgResponseResponse;  
1842 -}  
1843 -  
1844 -export type PutStrategyruleResponseSuccess = PutStrategyruleResponse[200];  
1845 -/**  
1846 - * @description  
1847 - * 更新战法规则  
1848 - * 更新战法规则  
1849 - * @tags 战法规则库  
1850 - * @produces application/json  
1851 - * @consumes application/json  
1852 - */  
1853 -export const putStrategyrule = /* #__PURE__ */ (() => {  
1854 - const method = "put";  
1855 - const url = "/strategyrule";  
1856 - function request(  
1857 - option: PutStrategyruleOption  
1858 - ): Promise<PutStrategyruleResponseSuccess> {  
1859 - return requester(request.url, {  
1860 - method: request.method,  
1861 - ...option,  
1862 - }) as unknown as Promise<PutStrategyruleResponseSuccess>;  
1863 - }  
1864 -  
1865 - /** http method */  
1866 - request.method = method;  
1867 - /** request url */  
1868 - request.url = url;  
1869 - return request;  
1870 -})();  
1871 -  
1872 -/** @description request parameter type for postStrategyrule */  
1873 -export interface PostStrategyruleOption {  
1874 - /**  
1875 - * @description  
1876 - * 战法规则信息  
1877 - */  
1878 - body: {  
1879 - /**  
1880 - @description  
1881 - 战法规则信息 */  
1882 - request: ZFWJInternalPkgRequestCreateStrategyRuleRequest;  
1883 - };  
1884 -}  
1885 -  
1886 -/** @description response type for postStrategyrule */  
1887 -export interface PostStrategyruleResponse {  
1888 - /**  
1889 - * @description  
1890 - * OK  
1891 - */  
1892 - 200: ZFWJInternalPkgResponseResponse;  
1893 -}  
1894 -  
1895 -export type PostStrategyruleResponseSuccess = PostStrategyruleResponse[200];  
1896 -/**  
1897 - * @description  
1898 - * 创建战法规则  
1899 - * 创建战法规则  
1900 - * @tags 战法规则库  
1901 - * @produces application/json  
1902 - * @consumes application/json  
1903 - */  
1904 -export const postStrategyrule = /* #__PURE__ */ (() => {  
1905 - const method = "post";  
1906 - const url = "/strategyrule";  
1907 - function request(  
1908 - option: PostStrategyruleOption  
1909 - ): Promise<PostStrategyruleResponseSuccess> {  
1910 - return requester(request.url, {  
1911 - method: request.method,  
1912 - ...option,  
1913 - }) as unknown as Promise<PostStrategyruleResponseSuccess>;  
1914 - }  
1915 -  
1916 - /** http method */  
1917 - request.method = method;  
1918 - /** request url */  
1919 - request.url = url;  
1920 - return request;  
1921 -})();  
1922 -  
1923 -/** @description request parameter type for deleteStrategyrule */  
1924 -export interface DeleteStrategyruleOption {  
1925 - /**  
1926 - * @description  
1927 - * Id  
1928 - */  
1929 - query: {  
1930 - /**  
1931 - @description  
1932 - Id */  
1933 - Id: string;  
1934 - };  
1935 -}  
1936 -  
1937 -/** @description response type for deleteStrategyrule */  
1938 -export interface DeleteStrategyruleResponse {  
1939 - /**  
1940 - * @description  
1941 - * OK  
1942 - */  
1943 - 200: ZFWJInternalPkgResponseResponse;  
1944 -}  
1945 -  
1946 -export type DeleteStrategyruleResponseSuccess = DeleteStrategyruleResponse[200];  
1947 -/**  
1948 - * @description  
1949 - * 删除战法规则  
1950 - * 删除战法规则  
1951 - * @tags 战法规则库  
1952 - * @produces application/json  
1953 - * @consumes application/json  
1954 - */  
1955 -export const deleteStrategyrule = /* #__PURE__ */ (() => {  
1956 - const method = "delete";  
1957 - const url = "/strategyrule";  
1958 - function request(  
1959 - option: DeleteStrategyruleOption  
1960 - ): Promise<DeleteStrategyruleResponseSuccess> {  
1961 - return requester(request.url, {  
1962 - method: request.method,  
1963 - ...option,  
1964 - }) as unknown as Promise<DeleteStrategyruleResponseSuccess>;  
1965 - }  
1966 -  
1967 - /** http method */  
1968 - request.method = method;  
1969 - /** request url */  
1970 - request.url = url;  
1971 - return request;  
1972 -})();  
1973 -  
1974 -/** @description request parameter type for postStrategyruleArchive */  
1975 -export interface PostStrategyruleArchiveOption {  
1976 - /**  
1977 - * @description  
1978 - * 战法规则信息  
1979 - */  
1980 - body: {  
1981 - /**  
1982 - @description  
1983 - 战法规则信息 */  
1984 - request: ZFWJInternalPkgRequestStrategyRuleArchiveRequest;  
1985 - };  
1986 -}  
1987 -  
1988 -/** @description response type for postStrategyruleArchive */  
1989 -export interface PostStrategyruleArchiveResponse {  
1990 - /**  
1991 - * @description  
1992 - * OK  
1993 - */  
1994 - 200: ZFWJInternalPkgResponseResponse;  
1995 -}  
1996 -  
1997 -export type PostStrategyruleArchiveResponseSuccess =  
1998 - PostStrategyruleArchiveResponse[200];  
1999 -/**  
2000 - * @description  
2001 - * 战法规则入库  
2002 - * 战法规则入库  
2003 - * @tags 战法规则库  
2004 - * @produces application/json  
2005 - * @consumes application/json  
2006 - */  
2007 -export const postStrategyruleArchive = /* #__PURE__ */ (() => {  
2008 - const method = "post";  
2009 - const url = "/strategyrule/archive";  
2010 - function request(  
2011 - option: PostStrategyruleArchiveOption  
2012 - ): Promise<PostStrategyruleArchiveResponseSuccess> {  
2013 - return requester(request.url, {  
2014 - method: request.method,  
2015 - ...option,  
2016 - }) as unknown as Promise<PostStrategyruleArchiveResponseSuccess>;  
2017 - }  
2018 -  
2019 - /** http method */  
2020 - request.method = method;  
2021 - /** request url */  
2022 - request.url = url;  
2023 - return request;  
2024 -})();  
2025 -  
2026 -/** @description request parameter type for getStrategyruleList */  
2027 -export interface GetStrategyruleListOption {  
2028 - /**  
2029 - * @description  
2030 - * PageNum  
2031 - */  
2032 - query: {  
2033 - /**  
2034 - @description  
2035 - PageNum */  
2036 - PageNum: number;  
2037 - /**  
2038 - @description  
2039 - PageSize */  
2040 - PageSize: number;  
2041 - /**  
2042 - @description  
2043 - StrategyType */  
2044 - StrategyType?: string;  
2045 - /**  
2046 - @description  
2047 - Level */  
2048 - Level?: number;  
2049 - /**  
2050 - @description  
2051 - Scenario */  
2052 - Scenario?: number;  
2053 - /**  
2054 - @description  
2055 - Source */  
2056 - Source?: number;  
2057 - /**  
2058 - @description  
2059 - TaskType */  
2060 - TaskType?: number;  
2061 - /**  
2062 - @description  
2063 - StrategyName */  
2064 - StrategyName?: string;  
2065 - };  
2066 -}  
2067 -  
2068 -/** @description response type for getStrategyruleList */  
2069 -export interface GetStrategyruleListResponse {  
2070 - /**  
2071 - * @description  
2072 - * OK  
2073 - */  
2074 - 200: ZFWJInternalPkgResponseResponse;  
2075 -}  
2076 -  
2077 -export type GetStrategyruleListResponseSuccess =  
2078 - GetStrategyruleListResponse[200];  
2079 -/**  
2080 - * @description  
2081 - * 获取战法规则列表  
2082 - * 获取战法规则列表  
2083 - * @tags 战法规则库  
2084 - * @produces application/json  
2085 - * @consumes application/json  
2086 - */  
2087 -export const getStrategyruleList = /* #__PURE__ */ (() => {  
2088 - const method = "get";  
2089 - const url = "/strategyrule/list";  
2090 - function request(  
2091 - option: GetStrategyruleListOption  
2092 - ): Promise<GetStrategyruleListResponseSuccess> {  
2093 - return requester(request.url, {  
2094 - method: request.method,  
2095 - ...option,  
2096 - }) as unknown as Promise<GetStrategyruleListResponseSuccess>;  
2097 - }  
2098 -  
2099 - /** http method */  
2100 - request.method = method;  
2101 - /** request url */  
2102 - request.url = url;  
2103 - return request;  
2104 -})();  
2105 -  
2106 -/** @description request parameter type for putTextminingtask */  
2107 -export interface PutTextminingtaskOption {  
2108 - /**  
2109 - * @description  
2110 - * params  
2111 - */  
2112 - body: {  
2113 - /**  
2114 - @description  
2115 - params */  
2116 - request: ZFWJInternalPkgRequestUpdateTmtRequest;  
2117 - };  
2118 -}  
2119 -  
2120 -/** @description response type for putTextminingtask */  
2121 -export interface PutTextminingtaskResponse {  
2122 - /**  
2123 - * @description  
2124 - * OK  
2125 - */  
2126 - 200: ZFWJInternalPkgResponseResponse;  
2127 -}  
2128 -  
2129 -export type PutTextminingtaskResponseSuccess = PutTextminingtaskResponse[200];  
2130 -/**  
2131 - * @description  
2132 - * 任务编辑  
2133 - * @tags 文本数据挖掘模块  
2134 - * @produces application/json  
2135 - * @consumes application/json  
2136 - */  
2137 -export const putTextminingtask = /* #__PURE__ */ (() => {  
2138 - const method = "put";  
2139 - const url = "/textminingtask";  
2140 - function request(  
2141 - option: PutTextminingtaskOption  
2142 - ): Promise<PutTextminingtaskResponseSuccess> {  
2143 - return requester(request.url, {  
2144 - method: request.method,  
2145 - ...option,  
2146 - }) as unknown as Promise<PutTextminingtaskResponseSuccess>;  
2147 - }  
2148 -  
2149 - /** http method */  
2150 - request.method = method;  
2151 - /** request url */  
2152 - request.url = url;  
2153 - return request;  
2154 -})();  
2155 -  
2156 -/** @description request parameter type for postTextminingtask */  
2157 -export interface PostTextminingtaskOption {  
2158 - /**  
2159 - * @description  
2160 - * params  
2161 - */  
2162 - body: {  
2163 - /**  
2164 - @description  
2165 - params */  
2166 - request: ZFWJInternalPkgRequestCreateTmtRequest;  
2167 - };  
2168 -}  
2169 -  
2170 -/** @description response type for postTextminingtask */  
2171 -export interface PostTextminingtaskResponse {  
2172 - /**  
2173 - * @description  
2174 - * OK  
2175 - */  
2176 - 200: ZFWJInternalPkgResponseResponse;  
2177 -}  
2178 -  
2179 -export type PostTextminingtaskResponseSuccess = PostTextminingtaskResponse[200];  
2180 -/**  
2181 - * @description  
2182 - * 创建任务  
2183 - * @tags 文本数据挖掘模块  
2184 - * @produces application/json  
2185 - * @consumes application/json  
2186 - */  
2187 -export const postTextminingtask = /* #__PURE__ */ (() => { 6 +import type {} from "./definition";
  7 +
  8 +/** @description request parameter type for postErpOrderListByPage */
  9 +export interface PostErpOrderListByPageOption {
  10 + body?: {
  11 + root?: {
  12 + /**
  13 + @description
  14 + 当前页码 */
  15 + current: number;
  16 + /**
  17 + @description
  18 + 每页条数 */
  19 + size: string;
  20 + /**
  21 + @description
  22 + 查询参数 */
  23 + search: {
  24 + /**
  25 + @description
  26 + 主订单id */
  27 + mainOrderId: string;
  28 + /**
  29 + @description
  30 + 商品名称 */
  31 + productName: string;
  32 + };
  33 + };
  34 + };
  35 +}
  36 +
  37 +/** @description response type for postErpOrderListByPage */
  38 +export interface PostErpOrderListByPageResponse {
  39 + /**
  40 + * @description
  41 + * successful operation
  42 + */
  43 + 200: {
  44 + data?: {
  45 + current?: number;
  46 + pages?: number;
  47 + records?: Array<{
  48 + main_order_id: number;
  49 + sales_code: string;
  50 + customer_name: string;
  51 + customer_contact_number: string;
  52 + customer_shipping_address: string;
  53 + institution_contact_name: string;
  54 + institution: string;
  55 + main_order_create_time: string;
  56 + main_order_update_time: string;
  57 + main_order_create_by_name: string;
  58 + main_order_update_by_name: any;
  59 + /**
  60 + @description
  61 + 权限按钮 */
  62 + btns: string;
  63 + sub_orders: Array<{
  64 + sub_order_id: number;
  65 + product_code: number;
  66 + product_name: string;
  67 + quantity: number;
  68 + product_price: number;
  69 + unit: string;
  70 + parameters: any;
  71 + total_payment: number;
  72 + sub_order_payment: number;
  73 + is_cancel: number;
  74 + logistics_status: string;
  75 + payment_status: string;
  76 + payment_method: string;
  77 + payment_channel: string;
  78 + payment_transaction_id: any;
  79 + invoice_information: any;
  80 + invoicing_status: string;
  81 + product_belong_department: string;
  82 + waybill_number: any;
  83 + notes: any;
  84 + examine_notes: any;
  85 + order_status: string;
  86 + sub_order_create_time: string;
  87 + sub_order_update_time: string;
  88 + sub_order_create_by_name: string;
  89 + sub_order_update_by_name: any;
  90 + /**
  91 + @description
  92 + 权限按钮 */
  93 + btns: string;
  94 + }>;
  95 + }>;
  96 + total?: number;
  97 + size: number;
  98 + };
  99 + message?: string;
  100 + code?: number;
  101 + };
  102 +}
  103 +
  104 +export type PostErpOrderListByPageResponseSuccess =
  105 + PostErpOrderListByPageResponse[200];
  106 +/**
  107 + * @description
  108 + * 订单列表查询
  109 + * @tags 公共分类
  110 + * @consumes application/json
  111 + */
  112 +export const postErpOrderListByPage = /* #__PURE__ */ (() => {
2188 const method = "post"; 113 const method = "post";
2189 - const url = "/textminingtask";  
2190 - function request(  
2191 - option: PostTextminingtaskOption  
2192 - ): Promise<PostTextminingtaskResponseSuccess> {  
2193 - return requester(request.url, {  
2194 - method: request.method,  
2195 - ...option,  
2196 - }) as unknown as Promise<PostTextminingtaskResponseSuccess>;  
2197 - }  
2198 -  
2199 - /** http method */  
2200 - request.method = method;  
2201 - /** request url */  
2202 - request.url = url;  
2203 - return request;  
2204 -})();  
2205 -  
2206 -/** @description request parameter type for deleteTextminingtask */  
2207 -export interface DeleteTextminingtaskOption {  
2208 - /**  
2209 - * @description  
2210 - * 任务id  
2211 - */  
2212 - query: {  
2213 - /**  
2214 - @description  
2215 - 任务id */  
2216 - id: string;  
2217 - };  
2218 -}  
2219 -  
2220 -/** @description response type for deleteTextminingtask */  
2221 -export interface DeleteTextminingtaskResponse {  
2222 - /**  
2223 - * @description  
2224 - * OK  
2225 - */  
2226 - 200: ZFWJInternalPkgResponseResponse;  
2227 -}  
2228 -  
2229 -export type DeleteTextminingtaskResponseSuccess =  
2230 - DeleteTextminingtaskResponse[200];  
2231 -/**  
2232 - * @description  
2233 - * 删除任务  
2234 - * @tags 文本数据挖掘模块  
2235 - * @produces application/json  
2236 - * @consumes application/json  
2237 - */  
2238 -export const deleteTextminingtask = /* #__PURE__ */ (() => {  
2239 - const method = "delete";  
2240 - const url = "/textminingtask";  
2241 - function request(  
2242 - option: DeleteTextminingtaskOption  
2243 - ): Promise<DeleteTextminingtaskResponseSuccess> {  
2244 - return requester(request.url, {  
2245 - method: request.method,  
2246 - ...option,  
2247 - }) as unknown as Promise<DeleteTextminingtaskResponseSuccess>;  
2248 - }  
2249 -  
2250 - /** http method */  
2251 - request.method = method;  
2252 - /** request url */  
2253 - request.url = url;  
2254 - return request;  
2255 -})();  
2256 -  
2257 -/** @description request parameter type for getTextminingtaskDetail */  
2258 -export interface GetTextminingtaskDetailOption {  
2259 - /**  
2260 - * @description  
2261 - * 任务id  
2262 - */  
2263 - query: {  
2264 - /**  
2265 - @description  
2266 - 任务id */  
2267 - id: string;  
2268 - };  
2269 -}  
2270 -  
2271 -/** @description response type for getTextminingtaskDetail */  
2272 -export interface GetTextminingtaskDetailResponse {  
2273 - /**  
2274 - * @description  
2275 - * OK  
2276 - */  
2277 - 200: ZFWJInternalPkgResponseResponse;  
2278 -}  
2279 -  
2280 -export type GetTextminingtaskDetailResponseSuccess =  
2281 - GetTextminingtaskDetailResponse[200];  
2282 -/**  
2283 - * @description  
2284 - * 根据任务id获取任务信息、战法列表  
2285 - * @tags 文本数据挖掘模块  
2286 - * @produces application/json  
2287 - * @consumes application/json  
2288 - */  
2289 -export const getTextminingtaskDetail = /* #__PURE__ */ (() => {  
2290 - const method = "get";  
2291 - const url = "/textminingtask/detail"; 114 + const url = "/erp/order/listByPage";
2292 function request( 115 function request(
2293 - option: GetTextminingtaskDetailOption  
2294 - ): Promise<GetTextminingtaskDetailResponseSuccess> { 116 + option?: PostErpOrderListByPageOption
  117 + ): Promise<PostErpOrderListByPageResponseSuccess> {
2295 return requester(request.url, { 118 return requester(request.url, {
2296 method: request.method, 119 method: request.method,
2297 ...option, 120 ...option,
2298 - }) as unknown as Promise<GetTextminingtaskDetailResponseSuccess>; 121 + }) as unknown as Promise<PostErpOrderListByPageResponseSuccess>;
2299 } 122 }
2300 123
2301 /** http method */ 124 /** http method */
@@ -2305,213 +128,87 @@ export const getTextminingtaskDetail = /* #__PURE__ */ (() =&gt; { @@ -2305,213 +128,87 @@ export const getTextminingtaskDetail = /* #__PURE__ */ (() =&gt; {
2305 return request; 128 return request;
2306 })(); 129 })();
2307 130
2308 -/** @description request parameter type for getTextminingtaskList */  
2309 -export interface GetTextminingtaskListOption { 131 +/** @description request parameter type for postErpOrderAdd */
  132 +export interface PostErpOrderAddOption {
2310 /** 133 /**
2311 * @description 134 * @description
2312 - * 页码  
2313 - * @default 1 135 + * add_token (Only:undefined)
2314 */ 136 */
2315 - query: {  
2316 - /**  
2317 - @description  
2318 - 页码  
2319 - @default 1 */  
2320 - PageNum: string;  
2321 - /**  
2322 - @description  
2323 - 每页数量  
2324 - @default 10 */  
2325 - PageSize: string; 137 + header: {
2326 /** 138 /**
2327 @description 139 @description
2328 - 任务名称 */  
2329 - TaskName?: string; 140 + add_token (Only:undefined) */
  141 + add_token: string;
2330 }; 142 };
2331 } 143 }
2332 144
2333 -/** @description response type for getTextminingtaskList */  
2334 -export interface GetTextminingtaskListResponse {  
2335 - /**  
2336 - * @description  
2337 - * OK  
2338 - */  
2339 - 200: ZFWJInternalPkgResponseResponse;  
2340 -}  
2341 -  
2342 -export type GetTextminingtaskListResponseSuccess =  
2343 - GetTextminingtaskListResponse[200];  
2344 -/**  
2345 - * @description  
2346 - * 支持分页  
2347 - * 获取所有任务  
2348 - * @tags 文本数据挖掘模块  
2349 - * @produces application/json  
2350 - * @consumes application/json  
2351 - */  
2352 -export const getTextminingtaskList = /* #__PURE__ */ (() => {  
2353 - const method = "get";  
2354 - const url = "/textminingtask/list";  
2355 - function request(  
2356 - option: GetTextminingtaskListOption  
2357 - ): Promise<GetTextminingtaskListResponseSuccess> {  
2358 - return requester(request.url, {  
2359 - method: request.method,  
2360 - ...option,  
2361 - }) as unknown as Promise<GetTextminingtaskListResponseSuccess>;  
2362 - }  
2363 -  
2364 - /** http method */  
2365 - request.method = method;  
2366 - /** request url */  
2367 - request.url = url;  
2368 - return request;  
2369 -})();  
2370 -  
2371 -/** @description request parameter type for getTextminingtaskOriginalText */  
2372 -export interface GetTextminingtaskOriginalTextOption {  
2373 - /**  
2374 - * @description  
2375 - * 任务id  
2376 - */  
2377 - query: {  
2378 - /** 145 +/** @description request parameter type for postErpOrderAdd */
  146 +export interface PostErpOrderAddOption {
  147 + body?: {
  148 + root?: {
  149 + sales_code: string;
  150 + customer_name: string;
  151 + customer_contact_number: string;
  152 + customer_shipping_address: string;
  153 + institution_contact_name: string;
  154 + institution: string;
  155 + sub_orders: Array<{
  156 + product_code: number;
  157 + product_name: string;
  158 + quantity: number;
  159 + product_price: number;
  160 + unit: string;
  161 + parameters: string;
  162 + total_payment: number;
  163 + sub_order_payment: number;
  164 + payment_status: string;
  165 + payment_method: string;
  166 + payment_channel: string;
  167 + /**
2379 @description 168 @description
2380 - 任务id */  
2381 - id: string;  
2382 - };  
2383 -}  
2384 -  
2385 -/** @description response type for getTextminingtaskOriginalText */  
2386 -export interface GetTextminingtaskOriginalTextResponse {  
2387 - /**  
2388 - * @description  
2389 - * OK  
2390 - */  
2391 - 200: ZFWJInternalPkgResponseResponse;  
2392 -}  
2393 -  
2394 -export type GetTextminingtaskOriginalTextResponseSuccess =  
2395 - GetTextminingtaskOriginalTextResponse[200];  
2396 -/**  
2397 - * @description  
2398 - * 根据任务id获取任务原文  
2399 - * @tags 文本数据挖掘模块  
2400 - * @produces application/json  
2401 - * @consumes application/json  
2402 - */  
2403 -export const getTextminingtaskOriginalText = /* #__PURE__ */ (() => {  
2404 - const method = "get";  
2405 - const url = "/textminingtask/original-text";  
2406 - function request(  
2407 - option: GetTextminingtaskOriginalTextOption  
2408 - ): Promise<GetTextminingtaskOriginalTextResponseSuccess> {  
2409 - return requester(request.url, {  
2410 - method: request.method,  
2411 - ...option,  
2412 - }) as unknown as Promise<GetTextminingtaskOriginalTextResponseSuccess>;  
2413 - }  
2414 -  
2415 - /** http method */  
2416 - request.method = method;  
2417 - /** request url */  
2418 - request.url = url;  
2419 - return request;  
2420 -})();  
2421 -  
2422 -/** @description request parameter type for getTextminingtaskResult */  
2423 -export interface GetTextminingtaskResultOption {  
2424 - /**  
2425 - * @description  
2426 - * 任务id  
2427 - */  
2428 - query: {  
2429 - /** 169 + 预付必填 */
  170 + payment_transaction_id?: string;
  171 + /**
2430 @description 172 @description
2431 - 任务id */  
2432 - id: string; 173 + 需要开票必填 */
  174 + invoice_information?: string;
  175 + invoicing_status: string;
  176 + product_belong_department: string;
  177 + notes?: string;
  178 + }>;
  179 + };
2433 }; 180 };
2434 } 181 }
2435 182
2436 -/** @description response type for getTextminingtaskResult */  
2437 -export interface GetTextminingtaskResultResponse {  
2438 - /**  
2439 - * @description  
2440 - * OK  
2441 - */  
2442 - 200: ZFWJInternalPkgResponseResponse;  
2443 -}  
2444 -  
2445 -export type GetTextminingtaskResultResponseSuccess =  
2446 - GetTextminingtaskResultResponse[200];  
2447 -/**  
2448 - * @description  
2449 - * 根据战法id获取战法信息  
2450 - * @tags 文本数据挖掘模块  
2451 - * @produces application/json  
2452 - * @consumes application/json  
2453 - */  
2454 -export const getTextminingtaskResult = /* #__PURE__ */ (() => {  
2455 - const method = "get";  
2456 - const url = "/textminingtask/result";  
2457 - function request(  
2458 - option: GetTextminingtaskResultOption  
2459 - ): Promise<GetTextminingtaskResultResponseSuccess> {  
2460 - return requester(request.url, {  
2461 - method: request.method,  
2462 - ...option,  
2463 - }) as unknown as Promise<GetTextminingtaskResultResponseSuccess>;  
2464 - }  
2465 -  
2466 - /** http method */  
2467 - request.method = method;  
2468 - /** request url */  
2469 - request.url = url;  
2470 - return request;  
2471 -})();  
2472 -  
2473 -/** @description request parameter type for putTextminingtaskResult */  
2474 -export interface PutTextminingtaskResultOption { 183 +/** @description response type for postErpOrderAdd */
  184 +export interface PostErpOrderAddResponse {
2475 /** 185 /**
2476 * @description 186 * @description
2477 - * params 187 + * successful operation
2478 */ 188 */
2479 - body: {  
2480 - /**  
2481 - @description  
2482 - params */  
2483 - request: ZFWJInternalPkgRequestUpdateTmrRequest; 189 + 200: {
  190 + message?: string;
  191 + code?: number;
2484 }; 192 };
2485 } 193 }
2486 194
2487 -/** @description response type for putTextminingtaskResult */  
2488 -export interface PutTextminingtaskResultResponse {  
2489 - /**  
2490 - * @description  
2491 - * OK  
2492 - */  
2493 - 200: ZFWJInternalPkgResponseResponse;  
2494 -}  
2495 -  
2496 -export type PutTextminingtaskResultResponseSuccess =  
2497 - PutTextminingtaskResultResponse[200]; 195 +export type PostErpOrderAddResponseSuccess = PostErpOrderAddResponse[200];
2498 /** 196 /**
2499 * @description 197 * @description
2500 - * 战法编辑  
2501 - * @tags 文本数据挖掘模块  
2502 - * @produces application/json 198 + * 订单新增
  199 + * @tags 公共分类
2503 * @consumes application/json 200 * @consumes application/json
2504 */ 201 */
2505 -export const putTextminingtaskResult = /* #__PURE__ */ (() => {  
2506 - const method = "put";  
2507 - const url = "/textminingtask/result"; 202 +export const postErpOrderAdd = /* #__PURE__ */ (() => {
  203 + const method = "post";
  204 + const url = "/erp/order/add";
2508 function request( 205 function request(
2509 - option: PutTextminingtaskResultOption  
2510 - ): Promise<PutTextminingtaskResultResponseSuccess> { 206 + option: PostErpOrderAddOption
  207 + ): Promise<PostErpOrderAddResponseSuccess> {
2511 return requester(request.url, { 208 return requester(request.url, {
2512 method: request.method, 209 method: request.method,
2513 ...option, 210 ...option,
2514 - }) as unknown as Promise<PutTextminingtaskResultResponseSuccess>; 211 + }) as unknown as Promise<PostErpOrderAddResponseSuccess>;
2515 } 212 }
2516 213
2517 /** http method */ 214 /** http method */
@@ -2521,182 +218,67 @@ export const putTextminingtaskResult = /* #__PURE__ */ (() =&gt; { @@ -2521,182 +218,67 @@ export const putTextminingtaskResult = /* #__PURE__ */ (() =&gt; {
2521 return request; 218 return request;
2522 })(); 219 })();
2523 220
2524 -/** @description request parameter type for getTextminingtaskSentenceAnalyse */  
2525 -export interface GetTextminingtaskSentenceAnalyseOption {  
2526 - /**  
2527 - * @description  
2528 - * 战法id  
2529 - */  
2530 - query: {  
2531 - /**  
2532 - @description  
2533 - 战法id */  
2534 - id: string; 221 +/** @description request parameter type for postErpOrderUpdate */
  222 +export interface PostErpOrderUpdateOption {
  223 + body?: {
  224 + root?: {
  225 + sales_code: string;
  226 + customer_name: string;
  227 + customer_contact_number: string;
  228 + customer_shipping_address: string;
  229 + institution_contact_name: string;
  230 + institution: string;
  231 + sub_orders: Array<{
  232 + product_code: number;
  233 + product_name: string;
  234 + quantity: number;
  235 + product_price: number;
  236 + unit: string;
  237 + parameters: string;
  238 + total_payment: number;
  239 + sub_order_payment: number;
  240 + payment_status: string;
  241 + payment_method: string;
  242 + payment_channel: string;
  243 + payment_transaction_id?: string;
  244 + invoice_information?: string;
  245 + invoicing_status: string;
  246 + product_belong_department: string;
  247 + notes?: string;
  248 + }>;
  249 + };
2535 }; 250 };
2536 } 251 }
2537 252
2538 -/** @description response type for getTextminingtaskSentenceAnalyse */  
2539 -export interface GetTextminingtaskSentenceAnalyseResponse {  
2540 - /**  
2541 - * @description  
2542 - * OK  
2543 - */  
2544 - 200: ZFWJInternalPkgResponseResponse;  
2545 -}  
2546 -  
2547 -export type GetTextminingtaskSentenceAnalyseResponseSuccess =  
2548 - GetTextminingtaskSentenceAnalyseResponse[200];  
2549 -/**  
2550 - * @description  
2551 - * 战法分析  
2552 - * @tags 文本数据挖掘模块  
2553 - * @produces application/json  
2554 - * @consumes application/json  
2555 - */  
2556 -export const getTextminingtaskSentenceAnalyse = /* #__PURE__ */ (() => {  
2557 - const method = "get";  
2558 - const url = "/textminingtask/sentence-analyse";  
2559 - function request(  
2560 - option: GetTextminingtaskSentenceAnalyseOption  
2561 - ): Promise<GetTextminingtaskSentenceAnalyseResponseSuccess> {  
2562 - return requester(request.url, {  
2563 - method: request.method,  
2564 - ...option,  
2565 - }) as unknown as Promise<GetTextminingtaskSentenceAnalyseResponseSuccess>;  
2566 - }  
2567 -  
2568 - /** http method */  
2569 - request.method = method;  
2570 - /** request url */  
2571 - request.url = url;  
2572 - return request;  
2573 -})();  
2574 -  
2575 -/** @description request parameter type for postUpload */  
2576 -export interface PostUploadOption { 253 +/** @description response type for postErpOrderUpdate */
  254 +export interface PostErpOrderUpdateResponse {
2577 /** 255 /**
2578 * @description 256 * @description
2579 - * 文件 257 + * successful operation
2580 */ 258 */
2581 - formData: {  
2582 - /**  
2583 - @description  
2584 - 文件 */  
2585 - files: File; 259 + 200: {
  260 + message?: string;
  261 + code?: number;
2586 }; 262 };
2587 } 263 }
2588 264
2589 -/** @description response type for postUpload */  
2590 -export interface PostUploadResponse {  
2591 - /**  
2592 - * @description  
2593 - * OK  
2594 - */  
2595 - 200: ZFWJInternalPkgResponseResponse;  
2596 -}  
2597 -  
2598 -export type PostUploadResponseSuccess = PostUploadResponse[200]; 265 +export type PostErpOrderUpdateResponseSuccess = PostErpOrderUpdateResponse[200];
2599 /** 266 /**
2600 * @description 267 * @description
2601 - * 上传文件  
2602 - * @tags 文件上传模块  
2603 - * @produces application/json 268 + * 订单编辑
  269 + * @tags 公共分类
2604 * @consumes application/json 270 * @consumes application/json
2605 */ 271 */
2606 -export const postUpload = /* #__PURE__ */ (() => { 272 +export const postErpOrderUpdate = /* #__PURE__ */ (() => {
2607 const method = "post"; 273 const method = "post";
2608 - const url = "/upload";  
2609 - function request(  
2610 - option: PostUploadOption  
2611 - ): Promise<PostUploadResponseSuccess> {  
2612 - return requester(request.url, {  
2613 - method: request.method,  
2614 - ...option,  
2615 - }) as unknown as Promise<PostUploadResponseSuccess>;  
2616 - }  
2617 -  
2618 - /** http method */  
2619 - request.method = method;  
2620 - /** request url */  
2621 - request.url = url;  
2622 - return request;  
2623 -})();  
2624 -  
2625 -/** @description request parameter type for getUploadGeneratePresignedUrl */  
2626 -export interface GetUploadGeneratePresignedUrlOption {  
2627 - /**  
2628 - * @description  
2629 - * 文件名  
2630 - */  
2631 - query: {  
2632 - /**  
2633 - @description  
2634 - 文件名 */  
2635 - objectName: string;  
2636 - };  
2637 -}  
2638 -  
2639 -/** @description response type for getUploadGeneratePresignedUrl */  
2640 -export interface GetUploadGeneratePresignedUrlResponse {  
2641 - /**  
2642 - * @description  
2643 - * OK  
2644 - */  
2645 - 200: ZFWJInternalPkgResponseResponse;  
2646 -}  
2647 -  
2648 -export type GetUploadGeneratePresignedUrlResponseSuccess =  
2649 - GetUploadGeneratePresignedUrlResponse[200];  
2650 -/**  
2651 - * @description  
2652 - * 生成上传文件的预签名url  
2653 - * @tags 文件上传模块  
2654 - * @produces application/json  
2655 - * @consumes application/json  
2656 - */  
2657 -export const getUploadGeneratePresignedUrl = /* #__PURE__ */ (() => {  
2658 - const method = "get";  
2659 - const url = "/upload/generate-presigned-url"; 274 + const url = "/erp/order/update";
2660 function request( 275 function request(
2661 - option: GetUploadGeneratePresignedUrlOption  
2662 - ): Promise<GetUploadGeneratePresignedUrlResponseSuccess> { 276 + option?: PostErpOrderUpdateOption
  277 + ): Promise<PostErpOrderUpdateResponseSuccess> {
2663 return requester(request.url, { 278 return requester(request.url, {
2664 method: request.method, 279 method: request.method,
2665 ...option, 280 ...option,
2666 - }) as unknown as Promise<GetUploadGeneratePresignedUrlResponseSuccess>;  
2667 - }  
2668 -  
2669 - /** http method */  
2670 - request.method = method;  
2671 - /** request url */  
2672 - request.url = url;  
2673 - return request;  
2674 -})();  
2675 -  
2676 -/** @description response type for getUser */  
2677 -export interface GetUserResponse {  
2678 - /**  
2679 - * @description  
2680 - * OK  
2681 - */  
2682 - 200: ZFWJInternalPkgResponseResponse;  
2683 -}  
2684 -  
2685 -export type GetUserResponseSuccess = GetUserResponse[200];  
2686 -/**  
2687 - * @description  
2688 - * 获取用户信息  
2689 - * @tags 用户模块  
2690 - * @produces application/json  
2691 - * @consumes application/json  
2692 - */  
2693 -export const getUser = /* #__PURE__ */ (() => {  
2694 - const method = "get";  
2695 - const url = "/user";  
2696 - function request(): Promise<GetUserResponseSuccess> {  
2697 - return requester(request.url, {  
2698 - method: request.method,  
2699 - }) as unknown as Promise<GetUserResponseSuccess>; 281 + }) as unknown as Promise<PostErpOrderUpdateResponseSuccess>;
2700 } 282 }
2701 283
2702 /** http method */ 284 /** http method */
src/tsg.config.ts
  View file @8b2bcc8
@@ -33,7 +33,7 @@ const projects: Project[] = [ @@ -33,7 +33,7 @@ const projects: Project[] = [
33 * openapi 文档地址，可以是远程的json文件，也可以是本地的json文件 33 * openapi 文档地址，可以是远程的json文件，也可以是本地的json文件
34 * 如果使用本地文件，相对路径以当前'tsg.config.ts'为基准 34 * 如果使用本地文件，相对路径以当前'tsg.config.ts'为基准
35 * */ 35 * */
36 - source: 'http://11.1.1.144:31590/swagger/doc.json', 36 + source: 'http://172.18.192.1:8000/request.json',
37 37
38 // source: 'https://petstore3.swagger.io/api/v3/openapi.json', 38 // source: 'https://petstore3.swagger.io/api/v3/openapi.json',
39 // source: './fixture/pet.json', 39 // source: './fixture/pet.json',