1// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
2
3package openai
4
5import (
6 "context"
7 "encoding/json"
8 "errors"
9 "fmt"
10 "net/http"
11 "net/url"
12
13 "github.com/openai/openai-go/internal/apijson"
14 "github.com/openai/openai-go/internal/apiquery"
15 "github.com/openai/openai-go/internal/requestconfig"
16 "github.com/openai/openai-go/option"
17 "github.com/openai/openai-go/packages/pagination"
18 "github.com/openai/openai-go/packages/param"
19 "github.com/openai/openai-go/packages/resp"
20 "github.com/openai/openai-go/shared/constant"
21)
22
23// VectorStoreFileService contains methods and other services that help with
24// interacting with the openai API.
25//
26// Note, unlike clients, this service does not read variables from the environment
27// automatically. You should not instantiate this service directly, and instead use
28// the [NewVectorStoreFileService] method instead.
29type VectorStoreFileService struct {
30 Options []option.RequestOption
31}
32
33// NewVectorStoreFileService generates a new service that applies the given options
34// to each request. These options are applied after the parent client's options (if
35// there is one), and before any request-specific options.
36func NewVectorStoreFileService(opts ...option.RequestOption) (r VectorStoreFileService) {
37 r = VectorStoreFileService{}
38 r.Options = opts
39 return
40}
41
42// Create a vector store file by attaching a
43// [File](https://platform.openai.com/docs/api-reference/files) to a
44// [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object).
45func (r *VectorStoreFileService) New(ctx context.Context, vectorStoreID string, body VectorStoreFileNewParams, opts ...option.RequestOption) (res *VectorStoreFile, err error) {
46 opts = append(r.Options[:], opts...)
47 opts = append([]option.RequestOption{option.WithHeader("OpenAI-Beta", "assistants=v2")}, opts...)
48 if vectorStoreID == "" {
49 err = errors.New("missing required vector_store_id parameter")
50 return
51 }
52 path := fmt.Sprintf("vector_stores/%s/files", vectorStoreID)
53 err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
54 return
55}
56
57// Create a vector store file by attaching a
58// [File](https://platform.openai.com/docs/api-reference/files) to a
59// [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object).
60//
61// Polls the API and blocks until the task is complete.
62// Default polling interval is 1 second.
63func (r *VectorStoreFileService) NewAndPoll(ctx context.Context, vectorStoreId string, body VectorStoreFileNewParams, pollIntervalMs int, opts ...option.RequestOption) (res *VectorStoreFile, err error) {
64 file, err := r.New(ctx, vectorStoreId, body, opts...)
65 if err != nil {
66 return nil, err
67 }
68 return r.PollStatus(ctx, vectorStoreId, file.ID, pollIntervalMs, opts...)
69}
70
71// Upload a file to the `files` API and then attach it to the given vector store.
72//
73// Note the file will be asynchronously processed (you can use the alternative
74// polling helper method to wait for processing to complete).
75func (r *VectorStoreFileService) Upload(ctx context.Context, vectorStoreID string, body FileNewParams, opts ...option.RequestOption) (*VectorStoreFile, error) {
76 filesService := NewFileService(r.Options...)
77 fileObj, err := filesService.New(ctx, body, opts...)
78 if err != nil {
79 return nil, err
80 }
81 return r.New(ctx, vectorStoreID, VectorStoreFileNewParams{
82 FileID: fileObj.ID,
83 }, opts...)
84}
85
86// Add a file to a vector store and poll until processing is complete.
87// Default polling interval is 1 second.
88func (r *VectorStoreFileService) UploadAndPoll(ctx context.Context, vectorStoreID string, body FileNewParams, pollIntervalMs int, opts ...option.RequestOption) (*VectorStoreFile, error) {
89 res, err := r.Upload(ctx, vectorStoreID, body, opts...)
90 if err != nil {
91 return nil, err
92 }
93 return r.PollStatus(ctx, vectorStoreID, res.ID, pollIntervalMs, opts...)
94}
95
96// Retrieves a vector store file.
97func (r *VectorStoreFileService) Get(ctx context.Context, vectorStoreID string, fileID string, opts ...option.RequestOption) (res *VectorStoreFile, err error) {
98 opts = append(r.Options[:], opts...)
99 opts = append([]option.RequestOption{option.WithHeader("OpenAI-Beta", "assistants=v2")}, opts...)
100 if vectorStoreID == "" {
101 err = errors.New("missing required vector_store_id parameter")
102 return
103 }
104 if fileID == "" {
105 err = errors.New("missing required file_id parameter")
106 return
107 }
108 path := fmt.Sprintf("vector_stores/%s/files/%s", vectorStoreID, fileID)
109 err = requestconfig.ExecuteNewRequest(ctx, http.MethodGet, path, nil, &res, opts...)
110 return
111}
112
113// Update attributes on a vector store file.
114func (r *VectorStoreFileService) Update(ctx context.Context, vectorStoreID string, fileID string, body VectorStoreFileUpdateParams, opts ...option.RequestOption) (res *VectorStoreFile, err error) {
115 opts = append(r.Options[:], opts...)
116 opts = append([]option.RequestOption{option.WithHeader("OpenAI-Beta", "assistants=v2")}, opts...)
117 if vectorStoreID == "" {
118 err = errors.New("missing required vector_store_id parameter")
119 return
120 }
121 if fileID == "" {
122 err = errors.New("missing required file_id parameter")
123 return
124 }
125 path := fmt.Sprintf("vector_stores/%s/files/%s", vectorStoreID, fileID)
126 err = requestconfig.ExecuteNewRequest(ctx, http.MethodPost, path, body, &res, opts...)
127 return
128}
129
130// Returns a list of vector store files.
131func (r *VectorStoreFileService) List(ctx context.Context, vectorStoreID string, query VectorStoreFileListParams, opts ...option.RequestOption) (res *pagination.CursorPage[VectorStoreFile], err error) {
132 var raw *http.Response
133 opts = append(r.Options[:], opts...)
134 opts = append([]option.RequestOption{option.WithHeader("OpenAI-Beta", "assistants=v2"), option.WithResponseInto(&raw)}, opts...)
135 if vectorStoreID == "" {
136 err = errors.New("missing required vector_store_id parameter")
137 return
138 }
139 path := fmt.Sprintf("vector_stores/%s/files", vectorStoreID)
140 cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, query, &res, opts...)
141 if err != nil {
142 return nil, err
143 }
144 err = cfg.Execute()
145 if err != nil {
146 return nil, err
147 }
148 res.SetPageConfig(cfg, raw)
149 return res, nil
150}
151
152// Returns a list of vector store files.
153func (r *VectorStoreFileService) ListAutoPaging(ctx context.Context, vectorStoreID string, query VectorStoreFileListParams, opts ...option.RequestOption) *pagination.CursorPageAutoPager[VectorStoreFile] {
154 return pagination.NewCursorPageAutoPager(r.List(ctx, vectorStoreID, query, opts...))
155}
156
157// Delete a vector store file. This will remove the file from the vector store but
158// the file itself will not be deleted. To delete the file, use the
159// [delete file](https://platform.openai.com/docs/api-reference/files/delete)
160// endpoint.
161func (r *VectorStoreFileService) Delete(ctx context.Context, vectorStoreID string, fileID string, opts ...option.RequestOption) (res *VectorStoreFileDeleted, err error) {
162 opts = append(r.Options[:], opts...)
163 opts = append([]option.RequestOption{option.WithHeader("OpenAI-Beta", "assistants=v2")}, opts...)
164 if vectorStoreID == "" {
165 err = errors.New("missing required vector_store_id parameter")
166 return
167 }
168 if fileID == "" {
169 err = errors.New("missing required file_id parameter")
170 return
171 }
172 path := fmt.Sprintf("vector_stores/%s/files/%s", vectorStoreID, fileID)
173 err = requestconfig.ExecuteNewRequest(ctx, http.MethodDelete, path, nil, &res, opts...)
174 return
175}
176
177// Retrieve the parsed contents of a vector store file.
178func (r *VectorStoreFileService) Content(ctx context.Context, vectorStoreID string, fileID string, opts ...option.RequestOption) (res *pagination.Page[VectorStoreFileContentResponse], err error) {
179 var raw *http.Response
180 opts = append(r.Options[:], opts...)
181 opts = append([]option.RequestOption{option.WithHeader("OpenAI-Beta", "assistants=v2"), option.WithResponseInto(&raw)}, opts...)
182 if vectorStoreID == "" {
183 err = errors.New("missing required vector_store_id parameter")
184 return
185 }
186 if fileID == "" {
187 err = errors.New("missing required file_id parameter")
188 return
189 }
190 path := fmt.Sprintf("vector_stores/%s/files/%s/content", vectorStoreID, fileID)
191 cfg, err := requestconfig.NewRequestConfig(ctx, http.MethodGet, path, nil, &res, opts...)
192 if err != nil {
193 return nil, err
194 }
195 err = cfg.Execute()
196 if err != nil {
197 return nil, err
198 }
199 res.SetPageConfig(cfg, raw)
200 return res, nil
201}
202
203// Retrieve the parsed contents of a vector store file.
204func (r *VectorStoreFileService) ContentAutoPaging(ctx context.Context, vectorStoreID string, fileID string, opts ...option.RequestOption) *pagination.PageAutoPager[VectorStoreFileContentResponse] {
205 return pagination.NewPageAutoPager(r.Content(ctx, vectorStoreID, fileID, opts...))
206}
207
208// A list of files attached to a vector store.
209type VectorStoreFile struct {
210 // The identifier, which can be referenced in API endpoints.
211 ID string `json:"id,required"`
212 // The Unix timestamp (in seconds) for when the vector store file was created.
213 CreatedAt int64 `json:"created_at,required"`
214 // The last error associated with this vector store file. Will be `null` if there
215 // are no errors.
216 LastError VectorStoreFileLastError `json:"last_error,required"`
217 // The object type, which is always `vector_store.file`.
218 Object constant.VectorStoreFile `json:"object,required"`
219 // The status of the vector store file, which can be either `in_progress`,
220 // `completed`, `cancelled`, or `failed`. The status `completed` indicates that the
221 // vector store file is ready for use.
222 //
223 // Any of "in_progress", "completed", "cancelled", "failed".
224 Status VectorStoreFileStatus `json:"status,required"`
225 // The total vector store usage in bytes. Note that this may be different from the
226 // original file size.
227 UsageBytes int64 `json:"usage_bytes,required"`
228 // The ID of the
229 // [vector store](https://platform.openai.com/docs/api-reference/vector-stores/object)
230 // that the [File](https://platform.openai.com/docs/api-reference/files) is
231 // attached to.
232 VectorStoreID string `json:"vector_store_id,required"`
233 // Set of 16 key-value pairs that can be attached to an object. This can be useful
234 // for storing additional information about the object in a structured format, and
235 // querying for objects via API or the dashboard. Keys are strings with a maximum
236 // length of 64 characters. Values are strings with a maximum length of 512
237 // characters, booleans, or numbers.
238 Attributes map[string]VectorStoreFileAttributeUnion `json:"attributes,nullable"`
239 // The strategy used to chunk the file.
240 ChunkingStrategy FileChunkingStrategyUnion `json:"chunking_strategy"`
241 // Metadata for the response, check the presence of optional fields with the
242 // [resp.Field.IsPresent] method.
243 JSON struct {
244 ID resp.Field
245 CreatedAt resp.Field
246 LastError resp.Field
247 Object resp.Field
248 Status resp.Field
249 UsageBytes resp.Field
250 VectorStoreID resp.Field
251 Attributes resp.Field
252 ChunkingStrategy resp.Field
253 ExtraFields map[string]resp.Field
254 raw string
255 } `json:"-"`
256}
257
258// Returns the unmodified JSON received from the API
259func (r VectorStoreFile) RawJSON() string { return r.JSON.raw }
260func (r *VectorStoreFile) UnmarshalJSON(data []byte) error {
261 return apijson.UnmarshalRoot(data, r)
262}
263
264// The last error associated with this vector store file. Will be `null` if there
265// are no errors.
266type VectorStoreFileLastError struct {
267 // One of `server_error` or `rate_limit_exceeded`.
268 //
269 // Any of "server_error", "unsupported_file", "invalid_file".
270 Code string `json:"code,required"`
271 // A human-readable description of the error.
272 Message string `json:"message,required"`
273 // Metadata for the response, check the presence of optional fields with the
274 // [resp.Field.IsPresent] method.
275 JSON struct {
276 Code resp.Field
277 Message resp.Field
278 ExtraFields map[string]resp.Field
279 raw string
280 } `json:"-"`
281}
282
283// Returns the unmodified JSON received from the API
284func (r VectorStoreFileLastError) RawJSON() string { return r.JSON.raw }
285func (r *VectorStoreFileLastError) UnmarshalJSON(data []byte) error {
286 return apijson.UnmarshalRoot(data, r)
287}
288
289// The status of the vector store file, which can be either `in_progress`,
290// `completed`, `cancelled`, or `failed`. The status `completed` indicates that the
291// vector store file is ready for use.
292type VectorStoreFileStatus string
293
294const (
295 VectorStoreFileStatusInProgress VectorStoreFileStatus = "in_progress"
296 VectorStoreFileStatusCompleted VectorStoreFileStatus = "completed"
297 VectorStoreFileStatusCancelled VectorStoreFileStatus = "cancelled"
298 VectorStoreFileStatusFailed VectorStoreFileStatus = "failed"
299)
300
301// VectorStoreFileAttributeUnion contains all possible properties and values from
302// [string], [float64], [bool].
303//
304// Use the methods beginning with 'As' to cast the union to one of its variants.
305//
306// If the underlying value is not a json object, one of the following properties
307// will be valid: OfString OfFloat OfBool]
308type VectorStoreFileAttributeUnion struct {
309 // This field will be present if the value is a [string] instead of an object.
310 OfString string `json:",inline"`
311 // This field will be present if the value is a [float64] instead of an object.
312 OfFloat float64 `json:",inline"`
313 // This field will be present if the value is a [bool] instead of an object.
314 OfBool bool `json:",inline"`
315 JSON struct {
316 OfString resp.Field
317 OfFloat resp.Field
318 OfBool resp.Field
319 raw string
320 } `json:"-"`
321}
322
323func (u VectorStoreFileAttributeUnion) AsString() (v string) {
324 apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
325 return
326}
327
328func (u VectorStoreFileAttributeUnion) AsFloat() (v float64) {
329 apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
330 return
331}
332
333func (u VectorStoreFileAttributeUnion) AsBool() (v bool) {
334 apijson.UnmarshalRoot(json.RawMessage(u.JSON.raw), &v)
335 return
336}
337
338// Returns the unmodified JSON received from the API
339func (u VectorStoreFileAttributeUnion) RawJSON() string { return u.JSON.raw }
340
341func (r *VectorStoreFileAttributeUnion) UnmarshalJSON(data []byte) error {
342 return apijson.UnmarshalRoot(data, r)
343}
344
345type VectorStoreFileDeleted struct {
346 ID string `json:"id,required"`
347 Deleted bool `json:"deleted,required"`
348 Object constant.VectorStoreFileDeleted `json:"object,required"`
349 // Metadata for the response, check the presence of optional fields with the
350 // [resp.Field.IsPresent] method.
351 JSON struct {
352 ID resp.Field
353 Deleted resp.Field
354 Object resp.Field
355 ExtraFields map[string]resp.Field
356 raw string
357 } `json:"-"`
358}
359
360// Returns the unmodified JSON received from the API
361func (r VectorStoreFileDeleted) RawJSON() string { return r.JSON.raw }
362func (r *VectorStoreFileDeleted) UnmarshalJSON(data []byte) error {
363 return apijson.UnmarshalRoot(data, r)
364}
365
366type VectorStoreFileContentResponse struct {
367 // The text content
368 Text string `json:"text"`
369 // The content type (currently only `"text"`)
370 Type string `json:"type"`
371 // Metadata for the response, check the presence of optional fields with the
372 // [resp.Field.IsPresent] method.
373 JSON struct {
374 Text resp.Field
375 Type resp.Field
376 ExtraFields map[string]resp.Field
377 raw string
378 } `json:"-"`
379}
380
381// Returns the unmodified JSON received from the API
382func (r VectorStoreFileContentResponse) RawJSON() string { return r.JSON.raw }
383func (r *VectorStoreFileContentResponse) UnmarshalJSON(data []byte) error {
384 return apijson.UnmarshalRoot(data, r)
385}
386
387type VectorStoreFileNewParams struct {
388 // A [File](https://platform.openai.com/docs/api-reference/files) ID that the
389 // vector store should use. Useful for tools like `file_search` that can access
390 // files.
391 FileID string `json:"file_id,required"`
392 // Set of 16 key-value pairs that can be attached to an object. This can be useful
393 // for storing additional information about the object in a structured format, and
394 // querying for objects via API or the dashboard. Keys are strings with a maximum
395 // length of 64 characters. Values are strings with a maximum length of 512
396 // characters, booleans, or numbers.
397 Attributes map[string]VectorStoreFileNewParamsAttributeUnion `json:"attributes,omitzero"`
398 // The chunking strategy used to chunk the file(s). If not set, will use the `auto`
399 // strategy. Only applicable if `file_ids` is non-empty.
400 ChunkingStrategy FileChunkingStrategyParamUnion `json:"chunking_strategy,omitzero"`
401 paramObj
402}
403
404// IsPresent returns true if the field's value is not omitted and not the JSON
405// "null". To check if this field is omitted, use [param.IsOmitted].
406func (f VectorStoreFileNewParams) IsPresent() bool { return !param.IsOmitted(f) && !f.IsNull() }
407
408func (r VectorStoreFileNewParams) MarshalJSON() (data []byte, err error) {
409 type shadow VectorStoreFileNewParams
410 return param.MarshalObject(r, (*shadow)(&r))
411}
412
413// Only one field can be non-zero.
414//
415// Use [param.IsOmitted] to confirm if a field is set.
416type VectorStoreFileNewParamsAttributeUnion struct {
417 OfString param.Opt[string] `json:",omitzero,inline"`
418 OfFloat param.Opt[float64] `json:",omitzero,inline"`
419 OfBool param.Opt[bool] `json:",omitzero,inline"`
420 paramUnion
421}
422
423// IsPresent returns true if the field's value is not omitted and not the JSON
424// "null". To check if this field is omitted, use [param.IsOmitted].
425func (u VectorStoreFileNewParamsAttributeUnion) IsPresent() bool {
426 return !param.IsOmitted(u) && !u.IsNull()
427}
428func (u VectorStoreFileNewParamsAttributeUnion) MarshalJSON() ([]byte, error) {
429 return param.MarshalUnion[VectorStoreFileNewParamsAttributeUnion](u.OfString, u.OfFloat, u.OfBool)
430}
431
432func (u *VectorStoreFileNewParamsAttributeUnion) asAny() any {
433 if !param.IsOmitted(u.OfString) {
434 return &u.OfString.Value
435 } else if !param.IsOmitted(u.OfFloat) {
436 return &u.OfFloat.Value
437 } else if !param.IsOmitted(u.OfBool) {
438 return &u.OfBool.Value
439 }
440 return nil
441}
442
443type VectorStoreFileUpdateParams struct {
444 // Set of 16 key-value pairs that can be attached to an object. This can be useful
445 // for storing additional information about the object in a structured format, and
446 // querying for objects via API or the dashboard. Keys are strings with a maximum
447 // length of 64 characters. Values are strings with a maximum length of 512
448 // characters, booleans, or numbers.
449 Attributes map[string]VectorStoreFileUpdateParamsAttributeUnion `json:"attributes,omitzero,required"`
450 paramObj
451}
452
453// IsPresent returns true if the field's value is not omitted and not the JSON
454// "null". To check if this field is omitted, use [param.IsOmitted].
455func (f VectorStoreFileUpdateParams) IsPresent() bool { return !param.IsOmitted(f) && !f.IsNull() }
456
457func (r VectorStoreFileUpdateParams) MarshalJSON() (data []byte, err error) {
458 type shadow VectorStoreFileUpdateParams
459 return param.MarshalObject(r, (*shadow)(&r))
460}
461
462// Only one field can be non-zero.
463//
464// Use [param.IsOmitted] to confirm if a field is set.
465type VectorStoreFileUpdateParamsAttributeUnion struct {
466 OfString param.Opt[string] `json:",omitzero,inline"`
467 OfFloat param.Opt[float64] `json:",omitzero,inline"`
468 OfBool param.Opt[bool] `json:",omitzero,inline"`
469 paramUnion
470}
471
472// IsPresent returns true if the field's value is not omitted and not the JSON
473// "null". To check if this field is omitted, use [param.IsOmitted].
474func (u VectorStoreFileUpdateParamsAttributeUnion) IsPresent() bool {
475 return !param.IsOmitted(u) && !u.IsNull()
476}
477func (u VectorStoreFileUpdateParamsAttributeUnion) MarshalJSON() ([]byte, error) {
478 return param.MarshalUnion[VectorStoreFileUpdateParamsAttributeUnion](u.OfString, u.OfFloat, u.OfBool)
479}
480
481func (u *VectorStoreFileUpdateParamsAttributeUnion) asAny() any {
482 if !param.IsOmitted(u.OfString) {
483 return &u.OfString.Value
484 } else if !param.IsOmitted(u.OfFloat) {
485 return &u.OfFloat.Value
486 } else if !param.IsOmitted(u.OfBool) {
487 return &u.OfBool.Value
488 }
489 return nil
490}
491
492type VectorStoreFileListParams struct {
493 // A cursor for use in pagination. `after` is an object ID that defines your place
494 // in the list. For instance, if you make a list request and receive 100 objects,
495 // ending with obj_foo, your subsequent call can include after=obj_foo in order to
496 // fetch the next page of the list.
497 After param.Opt[string] `query:"after,omitzero" json:"-"`
498 // A cursor for use in pagination. `before` is an object ID that defines your place
499 // in the list. For instance, if you make a list request and receive 100 objects,
500 // starting with obj_foo, your subsequent call can include before=obj_foo in order
501 // to fetch the previous page of the list.
502 Before param.Opt[string] `query:"before,omitzero" json:"-"`
503 // A limit on the number of objects to be returned. Limit can range between 1 and
504 // 100, and the default is 20.
505 Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
506 // Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
507 //
508 // Any of "in_progress", "completed", "failed", "cancelled".
509 Filter VectorStoreFileListParamsFilter `query:"filter,omitzero" json:"-"`
510 // Sort order by the `created_at` timestamp of the objects. `asc` for ascending
511 // order and `desc` for descending order.
512 //
513 // Any of "asc", "desc".
514 Order VectorStoreFileListParamsOrder `query:"order,omitzero" json:"-"`
515 paramObj
516}
517
518// IsPresent returns true if the field's value is not omitted and not the JSON
519// "null". To check if this field is omitted, use [param.IsOmitted].
520func (f VectorStoreFileListParams) IsPresent() bool { return !param.IsOmitted(f) && !f.IsNull() }
521
522// URLQuery serializes [VectorStoreFileListParams]'s query parameters as
523// `url.Values`.
524func (r VectorStoreFileListParams) URLQuery() (v url.Values) {
525 return apiquery.MarshalWithSettings(r, apiquery.QuerySettings{
526 ArrayFormat: apiquery.ArrayQueryFormatBrackets,
527 NestedFormat: apiquery.NestedQueryFormatBrackets,
528 })
529}
530
531// Filter by file status. One of `in_progress`, `completed`, `failed`, `cancelled`.
532type VectorStoreFileListParamsFilter string
533
534const (
535 VectorStoreFileListParamsFilterInProgress VectorStoreFileListParamsFilter = "in_progress"
536 VectorStoreFileListParamsFilterCompleted VectorStoreFileListParamsFilter = "completed"
537 VectorStoreFileListParamsFilterFailed VectorStoreFileListParamsFilter = "failed"
538 VectorStoreFileListParamsFilterCancelled VectorStoreFileListParamsFilter = "cancelled"
539)
540
541// Sort order by the `created_at` timestamp of the objects. `asc` for ascending
542// order and `desc` for descending order.
543type VectorStoreFileListParamsOrder string
544
545const (
546 VectorStoreFileListParamsOrderAsc VectorStoreFileListParamsOrder = "asc"
547 VectorStoreFileListParamsOrderDesc VectorStoreFileListParamsOrder = "desc"
548)