1// Copyright 2025 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Code generated by the Google Gen AI SDK generator DO NOT EDIT.
16
17package genai
18
19import (
20 "context"
21 "fmt"
22 "iter"
23 "net/http"
24)
25
26func createCachedContentConfigToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
27 toObject = make(map[string]any)
28
29 fromTtl := getValueByPath(fromObject, []string{"ttl"})
30 if fromTtl != nil {
31 setValueByPath(parentObject, []string{"ttl"}, fromTtl)
32 }
33
34 fromExpireTime := getValueByPath(fromObject, []string{"expireTime"})
35 if fromExpireTime != nil {
36 setValueByPath(parentObject, []string{"expireTime"}, fromExpireTime)
37 }
38
39 fromDisplayName := getValueByPath(fromObject, []string{"displayName"})
40 if fromDisplayName != nil {
41 setValueByPath(parentObject, []string{"displayName"}, fromDisplayName)
42 }
43
44 fromContents := getValueByPath(fromObject, []string{"contents"})
45 if fromContents != nil {
46 fromContents, err = tContents(ac, fromContents)
47 if err != nil {
48 return nil, err
49 }
50
51 fromContents, err = applyConverterToSlice(ac, fromContents.([]any), contentToMldev)
52 if err != nil {
53 return nil, err
54 }
55
56 setValueByPath(parentObject, []string{"contents"}, fromContents)
57 }
58
59 fromSystemInstruction := getValueByPath(fromObject, []string{"systemInstruction"})
60 if fromSystemInstruction != nil {
61 fromSystemInstruction, err = tContent(ac, fromSystemInstruction)
62 if err != nil {
63 return nil, err
64 }
65
66 fromSystemInstruction, err = contentToMldev(ac, fromSystemInstruction.(map[string]any), toObject)
67 if err != nil {
68 return nil, err
69 }
70
71 setValueByPath(parentObject, []string{"systemInstruction"}, fromSystemInstruction)
72 }
73
74 fromTools := getValueByPath(fromObject, []string{"tools"})
75 if fromTools != nil {
76 fromTools, err = applyConverterToSlice(ac, fromTools.([]any), toolToMldev)
77 if err != nil {
78 return nil, err
79 }
80
81 setValueByPath(parentObject, []string{"tools"}, fromTools)
82 }
83
84 fromToolConfig := getValueByPath(fromObject, []string{"toolConfig"})
85 if fromToolConfig != nil {
86 fromToolConfig, err = toolConfigToMldev(ac, fromToolConfig.(map[string]any), toObject)
87 if err != nil {
88 return nil, err
89 }
90
91 setValueByPath(parentObject, []string{"toolConfig"}, fromToolConfig)
92 }
93
94 return toObject, nil
95}
96
97func createCachedContentParametersToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
98 toObject = make(map[string]any)
99
100 fromModel := getValueByPath(fromObject, []string{"model"})
101 if fromModel != nil {
102 fromModel, err = tCachesModel(ac, fromModel)
103 if err != nil {
104 return nil, err
105 }
106
107 setValueByPath(toObject, []string{"model"}, fromModel)
108 }
109
110 fromConfig := getValueByPath(fromObject, []string{"config"})
111 if fromConfig != nil {
112 fromConfig, err = createCachedContentConfigToMldev(ac, fromConfig.(map[string]any), toObject)
113 if err != nil {
114 return nil, err
115 }
116
117 setValueByPath(toObject, []string{"config"}, fromConfig)
118 }
119
120 return toObject, nil
121}
122
123func getCachedContentParametersToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
124 toObject = make(map[string]any)
125
126 fromName := getValueByPath(fromObject, []string{"name"})
127 if fromName != nil {
128 fromName, err = tCachedContentName(ac, fromName)
129 if err != nil {
130 return nil, err
131 }
132
133 setValueByPath(toObject, []string{"_url", "name"}, fromName)
134 }
135
136 fromConfig := getValueByPath(fromObject, []string{"config"})
137 if fromConfig != nil {
138 setValueByPath(toObject, []string{"config"}, fromConfig)
139 }
140
141 return toObject, nil
142}
143
144func deleteCachedContentParametersToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
145 toObject = make(map[string]any)
146
147 fromName := getValueByPath(fromObject, []string{"name"})
148 if fromName != nil {
149 fromName, err = tCachedContentName(ac, fromName)
150 if err != nil {
151 return nil, err
152 }
153
154 setValueByPath(toObject, []string{"_url", "name"}, fromName)
155 }
156
157 fromConfig := getValueByPath(fromObject, []string{"config"})
158 if fromConfig != nil {
159 setValueByPath(toObject, []string{"config"}, fromConfig)
160 }
161
162 return toObject, nil
163}
164
165func updateCachedContentConfigToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
166 toObject = make(map[string]any)
167
168 fromTtl := getValueByPath(fromObject, []string{"ttl"})
169 if fromTtl != nil {
170 setValueByPath(parentObject, []string{"ttl"}, fromTtl)
171 }
172
173 fromExpireTime := getValueByPath(fromObject, []string{"expireTime"})
174 if fromExpireTime != nil {
175 setValueByPath(parentObject, []string{"expireTime"}, fromExpireTime)
176 }
177
178 return toObject, nil
179}
180
181func updateCachedContentParametersToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
182 toObject = make(map[string]any)
183
184 fromName := getValueByPath(fromObject, []string{"name"})
185 if fromName != nil {
186 fromName, err = tCachedContentName(ac, fromName)
187 if err != nil {
188 return nil, err
189 }
190
191 setValueByPath(toObject, []string{"_url", "name"}, fromName)
192 }
193
194 fromConfig := getValueByPath(fromObject, []string{"config"})
195 if fromConfig != nil {
196 fromConfig, err = updateCachedContentConfigToMldev(ac, fromConfig.(map[string]any), toObject)
197 if err != nil {
198 return nil, err
199 }
200
201 setValueByPath(toObject, []string{"config"}, fromConfig)
202 }
203
204 return toObject, nil
205}
206
207func listCachedContentsConfigToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
208 toObject = make(map[string]any)
209
210 fromPageSize := getValueByPath(fromObject, []string{"pageSize"})
211 if fromPageSize != nil {
212 setValueByPath(parentObject, []string{"_query", "pageSize"}, fromPageSize)
213 }
214
215 fromPageToken := getValueByPath(fromObject, []string{"pageToken"})
216 if fromPageToken != nil {
217 setValueByPath(parentObject, []string{"_query", "pageToken"}, fromPageToken)
218 }
219
220 return toObject, nil
221}
222
223func listCachedContentsParametersToMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
224 toObject = make(map[string]any)
225
226 fromConfig := getValueByPath(fromObject, []string{"config"})
227 if fromConfig != nil {
228 fromConfig, err = listCachedContentsConfigToMldev(ac, fromConfig.(map[string]any), toObject)
229 if err != nil {
230 return nil, err
231 }
232
233 setValueByPath(toObject, []string{"config"}, fromConfig)
234 }
235
236 return toObject, nil
237}
238
239func createCachedContentConfigToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
240 toObject = make(map[string]any)
241
242 fromTtl := getValueByPath(fromObject, []string{"ttl"})
243 if fromTtl != nil {
244 setValueByPath(parentObject, []string{"ttl"}, fromTtl)
245 }
246
247 fromExpireTime := getValueByPath(fromObject, []string{"expireTime"})
248 if fromExpireTime != nil {
249 setValueByPath(parentObject, []string{"expireTime"}, fromExpireTime)
250 }
251
252 fromDisplayName := getValueByPath(fromObject, []string{"displayName"})
253 if fromDisplayName != nil {
254 setValueByPath(parentObject, []string{"displayName"}, fromDisplayName)
255 }
256
257 fromContents := getValueByPath(fromObject, []string{"contents"})
258 if fromContents != nil {
259 fromContents, err = tContents(ac, fromContents)
260 if err != nil {
261 return nil, err
262 }
263
264 fromContents, err = applyConverterToSlice(ac, fromContents.([]any), contentToVertex)
265 if err != nil {
266 return nil, err
267 }
268
269 setValueByPath(parentObject, []string{"contents"}, fromContents)
270 }
271
272 fromSystemInstruction := getValueByPath(fromObject, []string{"systemInstruction"})
273 if fromSystemInstruction != nil {
274 fromSystemInstruction, err = tContent(ac, fromSystemInstruction)
275 if err != nil {
276 return nil, err
277 }
278
279 fromSystemInstruction, err = contentToVertex(ac, fromSystemInstruction.(map[string]any), toObject)
280 if err != nil {
281 return nil, err
282 }
283
284 setValueByPath(parentObject, []string{"systemInstruction"}, fromSystemInstruction)
285 }
286
287 fromTools := getValueByPath(fromObject, []string{"tools"})
288 if fromTools != nil {
289 fromTools, err = applyConverterToSlice(ac, fromTools.([]any), toolToVertex)
290 if err != nil {
291 return nil, err
292 }
293
294 setValueByPath(parentObject, []string{"tools"}, fromTools)
295 }
296
297 fromToolConfig := getValueByPath(fromObject, []string{"toolConfig"})
298 if fromToolConfig != nil {
299 fromToolConfig, err = toolConfigToVertex(ac, fromToolConfig.(map[string]any), toObject)
300 if err != nil {
301 return nil, err
302 }
303
304 setValueByPath(parentObject, []string{"toolConfig"}, fromToolConfig)
305 }
306
307 return toObject, nil
308}
309
310func createCachedContentParametersToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
311 toObject = make(map[string]any)
312
313 fromModel := getValueByPath(fromObject, []string{"model"})
314 if fromModel != nil {
315 fromModel, err = tCachesModel(ac, fromModel)
316 if err != nil {
317 return nil, err
318 }
319
320 setValueByPath(toObject, []string{"model"}, fromModel)
321 }
322
323 fromConfig := getValueByPath(fromObject, []string{"config"})
324 if fromConfig != nil {
325 fromConfig, err = createCachedContentConfigToVertex(ac, fromConfig.(map[string]any), toObject)
326 if err != nil {
327 return nil, err
328 }
329
330 setValueByPath(toObject, []string{"config"}, fromConfig)
331 }
332
333 return toObject, nil
334}
335
336func getCachedContentParametersToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
337 toObject = make(map[string]any)
338
339 fromName := getValueByPath(fromObject, []string{"name"})
340 if fromName != nil {
341 fromName, err = tCachedContentName(ac, fromName)
342 if err != nil {
343 return nil, err
344 }
345
346 setValueByPath(toObject, []string{"_url", "name"}, fromName)
347 }
348
349 fromConfig := getValueByPath(fromObject, []string{"config"})
350 if fromConfig != nil {
351 setValueByPath(toObject, []string{"config"}, fromConfig)
352 }
353
354 return toObject, nil
355}
356
357func deleteCachedContentParametersToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
358 toObject = make(map[string]any)
359
360 fromName := getValueByPath(fromObject, []string{"name"})
361 if fromName != nil {
362 fromName, err = tCachedContentName(ac, fromName)
363 if err != nil {
364 return nil, err
365 }
366
367 setValueByPath(toObject, []string{"_url", "name"}, fromName)
368 }
369
370 fromConfig := getValueByPath(fromObject, []string{"config"})
371 if fromConfig != nil {
372 setValueByPath(toObject, []string{"config"}, fromConfig)
373 }
374
375 return toObject, nil
376}
377
378func updateCachedContentConfigToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
379 toObject = make(map[string]any)
380
381 fromTtl := getValueByPath(fromObject, []string{"ttl"})
382 if fromTtl != nil {
383 setValueByPath(parentObject, []string{"ttl"}, fromTtl)
384 }
385
386 fromExpireTime := getValueByPath(fromObject, []string{"expireTime"})
387 if fromExpireTime != nil {
388 setValueByPath(parentObject, []string{"expireTime"}, fromExpireTime)
389 }
390
391 return toObject, nil
392}
393
394func updateCachedContentParametersToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
395 toObject = make(map[string]any)
396
397 fromName := getValueByPath(fromObject, []string{"name"})
398 if fromName != nil {
399 fromName, err = tCachedContentName(ac, fromName)
400 if err != nil {
401 return nil, err
402 }
403
404 setValueByPath(toObject, []string{"_url", "name"}, fromName)
405 }
406
407 fromConfig := getValueByPath(fromObject, []string{"config"})
408 if fromConfig != nil {
409 fromConfig, err = updateCachedContentConfigToVertex(ac, fromConfig.(map[string]any), toObject)
410 if err != nil {
411 return nil, err
412 }
413
414 setValueByPath(toObject, []string{"config"}, fromConfig)
415 }
416
417 return toObject, nil
418}
419
420func listCachedContentsConfigToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
421 toObject = make(map[string]any)
422
423 fromPageSize := getValueByPath(fromObject, []string{"pageSize"})
424 if fromPageSize != nil {
425 setValueByPath(parentObject, []string{"_query", "pageSize"}, fromPageSize)
426 }
427
428 fromPageToken := getValueByPath(fromObject, []string{"pageToken"})
429 if fromPageToken != nil {
430 setValueByPath(parentObject, []string{"_query", "pageToken"}, fromPageToken)
431 }
432
433 return toObject, nil
434}
435
436func listCachedContentsParametersToVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
437 toObject = make(map[string]any)
438
439 fromConfig := getValueByPath(fromObject, []string{"config"})
440 if fromConfig != nil {
441 fromConfig, err = listCachedContentsConfigToVertex(ac, fromConfig.(map[string]any), toObject)
442 if err != nil {
443 return nil, err
444 }
445
446 setValueByPath(toObject, []string{"config"}, fromConfig)
447 }
448
449 return toObject, nil
450}
451
452func cachedContentFromMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
453 toObject = make(map[string]any)
454
455 fromName := getValueByPath(fromObject, []string{"name"})
456 if fromName != nil {
457 setValueByPath(toObject, []string{"name"}, fromName)
458 }
459
460 fromDisplayName := getValueByPath(fromObject, []string{"displayName"})
461 if fromDisplayName != nil {
462 setValueByPath(toObject, []string{"displayName"}, fromDisplayName)
463 }
464
465 fromModel := getValueByPath(fromObject, []string{"model"})
466 if fromModel != nil {
467 setValueByPath(toObject, []string{"model"}, fromModel)
468 }
469
470 fromCreateTime := getValueByPath(fromObject, []string{"createTime"})
471 if fromCreateTime != nil {
472 setValueByPath(toObject, []string{"createTime"}, fromCreateTime)
473 }
474
475 fromUpdateTime := getValueByPath(fromObject, []string{"updateTime"})
476 if fromUpdateTime != nil {
477 setValueByPath(toObject, []string{"updateTime"}, fromUpdateTime)
478 }
479
480 fromExpireTime := getValueByPath(fromObject, []string{"expireTime"})
481 if fromExpireTime != nil {
482 setValueByPath(toObject, []string{"expireTime"}, fromExpireTime)
483 }
484
485 fromUsageMetadata := getValueByPath(fromObject, []string{"usageMetadata"})
486 if fromUsageMetadata != nil {
487 setValueByPath(toObject, []string{"usageMetadata"}, fromUsageMetadata)
488 }
489
490 return toObject, nil
491}
492
493func deleteCachedContentResponseFromMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
494 toObject = make(map[string]any)
495
496 return toObject, nil
497}
498
499func listCachedContentsResponseFromMldev(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
500 toObject = make(map[string]any)
501
502 fromNextPageToken := getValueByPath(fromObject, []string{"nextPageToken"})
503 if fromNextPageToken != nil {
504 setValueByPath(toObject, []string{"nextPageToken"}, fromNextPageToken)
505 }
506
507 fromCachedContents := getValueByPath(fromObject, []string{"cachedContents"})
508 if fromCachedContents != nil {
509 fromCachedContents, err = applyConverterToSlice(ac, fromCachedContents.([]any), cachedContentFromMldev)
510 if err != nil {
511 return nil, err
512 }
513
514 setValueByPath(toObject, []string{"cachedContents"}, fromCachedContents)
515 }
516
517 return toObject, nil
518}
519
520func cachedContentFromVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
521 toObject = make(map[string]any)
522
523 fromName := getValueByPath(fromObject, []string{"name"})
524 if fromName != nil {
525 setValueByPath(toObject, []string{"name"}, fromName)
526 }
527
528 fromDisplayName := getValueByPath(fromObject, []string{"displayName"})
529 if fromDisplayName != nil {
530 setValueByPath(toObject, []string{"displayName"}, fromDisplayName)
531 }
532
533 fromModel := getValueByPath(fromObject, []string{"model"})
534 if fromModel != nil {
535 setValueByPath(toObject, []string{"model"}, fromModel)
536 }
537
538 fromCreateTime := getValueByPath(fromObject, []string{"createTime"})
539 if fromCreateTime != nil {
540 setValueByPath(toObject, []string{"createTime"}, fromCreateTime)
541 }
542
543 fromUpdateTime := getValueByPath(fromObject, []string{"updateTime"})
544 if fromUpdateTime != nil {
545 setValueByPath(toObject, []string{"updateTime"}, fromUpdateTime)
546 }
547
548 fromExpireTime := getValueByPath(fromObject, []string{"expireTime"})
549 if fromExpireTime != nil {
550 setValueByPath(toObject, []string{"expireTime"}, fromExpireTime)
551 }
552
553 fromUsageMetadata := getValueByPath(fromObject, []string{"usageMetadata"})
554 if fromUsageMetadata != nil {
555 setValueByPath(toObject, []string{"usageMetadata"}, fromUsageMetadata)
556 }
557
558 return toObject, nil
559}
560
561func deleteCachedContentResponseFromVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
562 toObject = make(map[string]any)
563
564 return toObject, nil
565}
566
567func listCachedContentsResponseFromVertex(ac *apiClient, fromObject map[string]any, parentObject map[string]any) (toObject map[string]any, err error) {
568 toObject = make(map[string]any)
569
570 fromNextPageToken := getValueByPath(fromObject, []string{"nextPageToken"})
571 if fromNextPageToken != nil {
572 setValueByPath(toObject, []string{"nextPageToken"}, fromNextPageToken)
573 }
574
575 fromCachedContents := getValueByPath(fromObject, []string{"cachedContents"})
576 if fromCachedContents != nil {
577 fromCachedContents, err = applyConverterToSlice(ac, fromCachedContents.([]any), cachedContentFromVertex)
578 if err != nil {
579 return nil, err
580 }
581
582 setValueByPath(toObject, []string{"cachedContents"}, fromCachedContents)
583 }
584
585 return toObject, nil
586}
587
588// Caches provides methods for managing the context caching.
589// You don't need to initiate this struct. Create a client instance via NewClient, and
590// then access Caches through client.Caches field.
591type Caches struct {
592 apiClient *apiClient
593}
594
595// Create creates a new cached content resource.
596func (m Caches) Create(ctx context.Context, model string, config *CreateCachedContentConfig) (*CachedContent, error) {
597 parameterMap := make(map[string]any)
598
599 kwargs := map[string]any{"model": model, "config": config}
600 deepMarshal(kwargs, ¶meterMap)
601
602 var httpOptions *HTTPOptions
603 if config == nil {
604 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, nil)
605 } else {
606 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, config.HTTPOptions)
607 config.HTTPOptions = nil
608 }
609 var response = new(CachedContent)
610 var responseMap map[string]any
611 var fromConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
612 var toConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
613 if m.apiClient.clientConfig.Backend == BackendVertexAI {
614 toConverter = createCachedContentParametersToVertex
615 fromConverter = cachedContentFromVertex
616 } else {
617 toConverter = createCachedContentParametersToMldev
618 fromConverter = cachedContentFromMldev
619 }
620
621 body, err := toConverter(m.apiClient, parameterMap, nil)
622 if err != nil {
623 return nil, err
624 }
625 var path string
626 var urlParams map[string]any
627 if _, ok := body["_url"]; ok {
628 urlParams = body["_url"].(map[string]any)
629 delete(body, "_url")
630 }
631 if m.apiClient.clientConfig.Backend == BackendVertexAI {
632 path, err = formatMap("cachedContents", urlParams)
633 } else {
634 path, err = formatMap("cachedContents", urlParams)
635 }
636 if err != nil {
637 return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
638 }
639 if _, ok := body["_query"]; ok {
640 query, err := createURLQuery(body["_query"].(map[string]any))
641 if err != nil {
642 return nil, err
643 }
644 path += "?" + query
645 delete(body, "_query")
646 }
647
648 if _, ok := body["config"]; ok {
649 delete(body, "config")
650 }
651 responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
652 if err != nil {
653 return nil, err
654 }
655 responseMap, err = fromConverter(m.apiClient, responseMap, nil)
656 if err != nil {
657 return nil, err
658 }
659 err = mapToStruct(responseMap, response)
660 if err != nil {
661 return nil, err
662 }
663 return response, nil
664}
665
666// Get gets a cached content resource.
667func (m Caches) Get(ctx context.Context, name string, config *GetCachedContentConfig) (*CachedContent, error) {
668 parameterMap := make(map[string]any)
669
670 kwargs := map[string]any{"name": name, "config": config}
671 deepMarshal(kwargs, ¶meterMap)
672
673 var httpOptions *HTTPOptions
674 if config == nil {
675 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, nil)
676 } else {
677 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, config.HTTPOptions)
678 config.HTTPOptions = nil
679 }
680 var response = new(CachedContent)
681 var responseMap map[string]any
682 var fromConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
683 var toConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
684 if m.apiClient.clientConfig.Backend == BackendVertexAI {
685 toConverter = getCachedContentParametersToVertex
686 fromConverter = cachedContentFromVertex
687 } else {
688 toConverter = getCachedContentParametersToMldev
689 fromConverter = cachedContentFromMldev
690 }
691
692 body, err := toConverter(m.apiClient, parameterMap, nil)
693 if err != nil {
694 return nil, err
695 }
696 var path string
697 var urlParams map[string]any
698 if _, ok := body["_url"]; ok {
699 urlParams = body["_url"].(map[string]any)
700 delete(body, "_url")
701 }
702 if m.apiClient.clientConfig.Backend == BackendVertexAI {
703 path, err = formatMap("{name}", urlParams)
704 } else {
705 path, err = formatMap("{name}", urlParams)
706 }
707 if err != nil {
708 return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
709 }
710 if _, ok := body["_query"]; ok {
711 query, err := createURLQuery(body["_query"].(map[string]any))
712 if err != nil {
713 return nil, err
714 }
715 path += "?" + query
716 delete(body, "_query")
717 }
718
719 if _, ok := body["config"]; ok {
720 delete(body, "config")
721 }
722 responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodGet, body, httpOptions)
723 if err != nil {
724 return nil, err
725 }
726 responseMap, err = fromConverter(m.apiClient, responseMap, nil)
727 if err != nil {
728 return nil, err
729 }
730 err = mapToStruct(responseMap, response)
731 if err != nil {
732 return nil, err
733 }
734 return response, nil
735}
736
737// Delete deletes a cached content resource.
738func (m Caches) Delete(ctx context.Context, name string, config *DeleteCachedContentConfig) (*DeleteCachedContentResponse, error) {
739 parameterMap := make(map[string]any)
740
741 kwargs := map[string]any{"name": name, "config": config}
742 deepMarshal(kwargs, ¶meterMap)
743
744 var httpOptions *HTTPOptions
745 if config == nil {
746 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, nil)
747 } else {
748 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, config.HTTPOptions)
749 config.HTTPOptions = nil
750 }
751 var response = new(DeleteCachedContentResponse)
752 var responseMap map[string]any
753 var fromConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
754 var toConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
755 if m.apiClient.clientConfig.Backend == BackendVertexAI {
756 toConverter = deleteCachedContentParametersToVertex
757 fromConverter = deleteCachedContentResponseFromVertex
758 } else {
759 toConverter = deleteCachedContentParametersToMldev
760 fromConverter = deleteCachedContentResponseFromMldev
761 }
762
763 body, err := toConverter(m.apiClient, parameterMap, nil)
764 if err != nil {
765 return nil, err
766 }
767 var path string
768 var urlParams map[string]any
769 if _, ok := body["_url"]; ok {
770 urlParams = body["_url"].(map[string]any)
771 delete(body, "_url")
772 }
773 if m.apiClient.clientConfig.Backend == BackendVertexAI {
774 path, err = formatMap("{name}", urlParams)
775 } else {
776 path, err = formatMap("{name}", urlParams)
777 }
778 if err != nil {
779 return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
780 }
781 if _, ok := body["_query"]; ok {
782 query, err := createURLQuery(body["_query"].(map[string]any))
783 if err != nil {
784 return nil, err
785 }
786 path += "?" + query
787 delete(body, "_query")
788 }
789
790 if _, ok := body["config"]; ok {
791 delete(body, "config")
792 }
793 responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodDelete, body, httpOptions)
794 if err != nil {
795 return nil, err
796 }
797 responseMap, err = fromConverter(m.apiClient, responseMap, nil)
798 if err != nil {
799 return nil, err
800 }
801 err = mapToStruct(responseMap, response)
802 if err != nil {
803 return nil, err
804 }
805 return response, nil
806}
807
808// Update updates a cached content resource.
809func (m Caches) Update(ctx context.Context, name string, config *UpdateCachedContentConfig) (*CachedContent, error) {
810 parameterMap := make(map[string]any)
811
812 kwargs := map[string]any{"name": name, "config": config}
813 deepMarshal(kwargs, ¶meterMap)
814
815 var httpOptions *HTTPOptions
816 if config == nil {
817 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, nil)
818 } else {
819 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, config.HTTPOptions)
820 config.HTTPOptions = nil
821 }
822 var response = new(CachedContent)
823 var responseMap map[string]any
824 var fromConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
825 var toConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
826 if m.apiClient.clientConfig.Backend == BackendVertexAI {
827 toConverter = updateCachedContentParametersToVertex
828 fromConverter = cachedContentFromVertex
829 } else {
830 toConverter = updateCachedContentParametersToMldev
831 fromConverter = cachedContentFromMldev
832 }
833
834 body, err := toConverter(m.apiClient, parameterMap, nil)
835 if err != nil {
836 return nil, err
837 }
838 var path string
839 var urlParams map[string]any
840 if _, ok := body["_url"]; ok {
841 urlParams = body["_url"].(map[string]any)
842 delete(body, "_url")
843 }
844 if m.apiClient.clientConfig.Backend == BackendVertexAI {
845 path, err = formatMap("{name}", urlParams)
846 } else {
847 path, err = formatMap("{name}", urlParams)
848 }
849 if err != nil {
850 return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
851 }
852 if _, ok := body["_query"]; ok {
853 query, err := createURLQuery(body["_query"].(map[string]any))
854 if err != nil {
855 return nil, err
856 }
857 path += "?" + query
858 delete(body, "_query")
859 }
860
861 if _, ok := body["config"]; ok {
862 delete(body, "config")
863 }
864 responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPatch, body, httpOptions)
865 if err != nil {
866 return nil, err
867 }
868 responseMap, err = fromConverter(m.apiClient, responseMap, nil)
869 if err != nil {
870 return nil, err
871 }
872 err = mapToStruct(responseMap, response)
873 if err != nil {
874 return nil, err
875 }
876 return response, nil
877}
878
879func (m Caches) list(ctx context.Context, config *ListCachedContentsConfig) (*ListCachedContentsResponse, error) {
880 parameterMap := make(map[string]any)
881
882 kwargs := map[string]any{"config": config}
883 deepMarshal(kwargs, ¶meterMap)
884
885 var httpOptions *HTTPOptions
886 if config == nil {
887 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, nil)
888 } else {
889 httpOptions = mergeHTTPOptions(m.apiClient.clientConfig, config.HTTPOptions)
890 config.HTTPOptions = nil
891 }
892 var response = new(ListCachedContentsResponse)
893 var responseMap map[string]any
894 var fromConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
895 var toConverter func(*apiClient, map[string]any, map[string]any) (map[string]any, error)
896 if m.apiClient.clientConfig.Backend == BackendVertexAI {
897 toConverter = listCachedContentsParametersToVertex
898 fromConverter = listCachedContentsResponseFromVertex
899 } else {
900 toConverter = listCachedContentsParametersToMldev
901 fromConverter = listCachedContentsResponseFromMldev
902 }
903
904 body, err := toConverter(m.apiClient, parameterMap, nil)
905 if err != nil {
906 return nil, err
907 }
908 var path string
909 var urlParams map[string]any
910 if _, ok := body["_url"]; ok {
911 urlParams = body["_url"].(map[string]any)
912 delete(body, "_url")
913 }
914 if m.apiClient.clientConfig.Backend == BackendVertexAI {
915 path, err = formatMap("cachedContents", urlParams)
916 } else {
917 path, err = formatMap("cachedContents", urlParams)
918 }
919 if err != nil {
920 return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
921 }
922 if _, ok := body["_query"]; ok {
923 query, err := createURLQuery(body["_query"].(map[string]any))
924 if err != nil {
925 return nil, err
926 }
927 path += "?" + query
928 delete(body, "_query")
929 }
930
931 if _, ok := body["config"]; ok {
932 delete(body, "config")
933 }
934 responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodGet, body, httpOptions)
935 if err != nil {
936 return nil, err
937 }
938 responseMap, err = fromConverter(m.apiClient, responseMap, nil)
939 if err != nil {
940 return nil, err
941 }
942 err = mapToStruct(responseMap, response)
943 if err != nil {
944 return nil, err
945 }
946 return response, nil
947}
948
949// List retrieves a paginated list of cached content resources.
950func (m Caches) List(ctx context.Context, config *ListCachedContentsConfig) (Page[CachedContent], error) {
951 listFunc := func(ctx context.Context, config map[string]any) ([]*CachedContent, string, error) {
952 var c ListCachedContentsConfig
953 if err := mapToStruct(config, &c); err != nil {
954 return nil, "", err
955 }
956 resp, err := m.list(ctx, &c)
957 if err != nil {
958 return nil, "", err
959 }
960 return resp.CachedContents, resp.NextPageToken, nil
961 }
962 c := make(map[string]any)
963 deepMarshal(config, &c)
964 return newPage(ctx, "cachedContents", c, listFunc)
965}
966
967// All retrieves all cached content resources.
968//
969// This method handles pagination internally, making multiple API calls as needed
970// to fetch all entries. It returns an iterator that yields each cached
971// content entry one by one. You do not need to manage pagination
972// tokens or make multiple calls to retrieve all data.
973func (m Caches) All(ctx context.Context) iter.Seq2[*CachedContent, error] {
974 listFunc := func(ctx context.Context, config map[string]any) ([]*CachedContent, string, error) {
975 var c ListCachedContentsConfig
976 if err := mapToStruct(config, &c); err != nil {
977 return nil, "", err
978 }
979 resp, err := m.list(ctx, &c)
980 if err != nil {
981 return nil, "", err
982 }
983 return resp.CachedContents, resp.NextPageToken, nil
984 }
985 p, err := newPage(ctx, "cachedContents", map[string]any{}, listFunc)
986 if err != nil {
987 return yieldErrorAndEndIterator[CachedContent](err)
988 }
989 return p.all(ctx)
990}