@gooddata/api-client-tiger 11.19.0-alpha.9 → 11.19.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (121) hide show
  1. package/esm/__version.d.ts +1 -1
  2. package/esm/__version.d.ts.map +1 -1
  3. package/esm/__version.js +1 -1
  4. package/esm/__version.js.map +1 -1
  5. package/esm/api-client-tiger.d.ts +1313 -1309
  6. package/esm/endpoints/aac/index.d.ts.map +1 -1
  7. package/esm/endpoints/aac/index.js +2 -0
  8. package/esm/endpoints/aac/index.js.map +1 -1
  9. package/esm/endpoints/actions/index.js +1 -1
  10. package/esm/endpoints/authActions/index.js +1 -1
  11. package/esm/endpoints/automation/index.js +1 -1
  12. package/esm/endpoints/entitiesObjects/index.js +1 -1
  13. package/esm/endpoints/execution/index.js +1 -1
  14. package/esm/endpoints/explain/index.js +1 -1
  15. package/esm/endpoints/export/index.js +1 -1
  16. package/esm/endpoints/genAI/index.js +1 -1
  17. package/esm/endpoints/labelElements/index.js +1 -1
  18. package/esm/endpoints/layout/index.js +1 -1
  19. package/esm/endpoints/locationStyle/index.js +1 -1
  20. package/esm/endpoints/profile/index.js +1 -1
  21. package/esm/endpoints/scanModel/index.js +1 -1
  22. package/esm/endpoints/smartFunctions/index.js +1 -1
  23. package/esm/endpoints/userManagement/index.js +1 -1
  24. package/esm/endpoints/validDescendants/index.js +1 -1
  25. package/esm/endpoints/validObjects/index.js +1 -1
  26. package/esm/gd-tiger-model/index.js +4 -4
  27. package/esm/generated/afm-rest-api/api.d.ts +560 -556
  28. package/esm/generated/afm-rest-api/api.d.ts.map +1 -1
  29. package/esm/generated/afm-rest-api/api.js +540 -410
  30. package/esm/generated/afm-rest-api/api.js.map +1 -1
  31. package/esm/generated/afm-rest-api/base.d.ts +2 -2
  32. package/esm/generated/afm-rest-api/base.d.ts.map +1 -1
  33. package/esm/generated/afm-rest-api/base.js +3 -1
  34. package/esm/generated/afm-rest-api/base.js.map +1 -1
  35. package/esm/generated/afm-rest-api/common.d.ts +1 -1
  36. package/esm/generated/afm-rest-api/common.d.ts.map +1 -1
  37. package/esm/generated/afm-rest-api/common.js +24 -14
  38. package/esm/generated/afm-rest-api/common.js.map +1 -1
  39. package/esm/generated/afm-rest-api/configuration.d.ts.map +1 -1
  40. package/esm/generated/afm-rest-api/configuration.js +3 -2
  41. package/esm/generated/afm-rest-api/configuration.js.map +1 -1
  42. package/esm/generated/afm-rest-api/index.d.ts.map +1 -1
  43. package/esm/generated/afm-rest-api/index.js +1 -0
  44. package/esm/generated/afm-rest-api/index.js.map +1 -1
  45. package/esm/generated/auth-json-api/api.d.ts +54 -54
  46. package/esm/generated/auth-json-api/api.d.ts.map +1 -1
  47. package/esm/generated/auth-json-api/api.js +89 -56
  48. package/esm/generated/auth-json-api/api.js.map +1 -1
  49. package/esm/generated/auth-json-api/base.d.ts +2 -2
  50. package/esm/generated/auth-json-api/base.d.ts.map +1 -1
  51. package/esm/generated/auth-json-api/base.js +3 -1
  52. package/esm/generated/auth-json-api/base.js.map +1 -1
  53. package/esm/generated/auth-json-api/common.d.ts +1 -1
  54. package/esm/generated/auth-json-api/common.d.ts.map +1 -1
  55. package/esm/generated/auth-json-api/common.js +24 -14
  56. package/esm/generated/auth-json-api/common.js.map +1 -1
  57. package/esm/generated/auth-json-api/configuration.d.ts.map +1 -1
  58. package/esm/generated/auth-json-api/configuration.js +3 -2
  59. package/esm/generated/auth-json-api/configuration.js.map +1 -1
  60. package/esm/generated/auth-json-api/index.d.ts.map +1 -1
  61. package/esm/generated/auth-json-api/index.js +1 -0
  62. package/esm/generated/auth-json-api/index.js.map +1 -1
  63. package/esm/generated/automation-json-api/api.d.ts +430 -430
  64. package/esm/generated/automation-json-api/api.d.ts.map +1 -1
  65. package/esm/generated/automation-json-api/api.js +95 -66
  66. package/esm/generated/automation-json-api/api.js.map +1 -1
  67. package/esm/generated/automation-json-api/base.d.ts +2 -2
  68. package/esm/generated/automation-json-api/base.d.ts.map +1 -1
  69. package/esm/generated/automation-json-api/base.js +3 -1
  70. package/esm/generated/automation-json-api/base.js.map +1 -1
  71. package/esm/generated/automation-json-api/common.d.ts +1 -1
  72. package/esm/generated/automation-json-api/common.d.ts.map +1 -1
  73. package/esm/generated/automation-json-api/common.js +24 -14
  74. package/esm/generated/automation-json-api/common.js.map +1 -1
  75. package/esm/generated/automation-json-api/configuration.d.ts.map +1 -1
  76. package/esm/generated/automation-json-api/configuration.js +3 -2
  77. package/esm/generated/automation-json-api/configuration.js.map +1 -1
  78. package/esm/generated/automation-json-api/index.d.ts.map +1 -1
  79. package/esm/generated/automation-json-api/index.js +1 -0
  80. package/esm/generated/automation-json-api/index.js.map +1 -1
  81. package/esm/generated/export-json-api/api.d.ts +257 -257
  82. package/esm/generated/export-json-api/api.d.ts.map +1 -1
  83. package/esm/generated/export-json-api/api.js +183 -138
  84. package/esm/generated/export-json-api/api.js.map +1 -1
  85. package/esm/generated/export-json-api/base.d.ts +2 -2
  86. package/esm/generated/export-json-api/base.d.ts.map +1 -1
  87. package/esm/generated/export-json-api/base.js +3 -1
  88. package/esm/generated/export-json-api/base.js.map +1 -1
  89. package/esm/generated/export-json-api/common.d.ts +1 -1
  90. package/esm/generated/export-json-api/common.d.ts.map +1 -1
  91. package/esm/generated/export-json-api/common.js +24 -14
  92. package/esm/generated/export-json-api/common.js.map +1 -1
  93. package/esm/generated/export-json-api/configuration.d.ts.map +1 -1
  94. package/esm/generated/export-json-api/configuration.js +3 -2
  95. package/esm/generated/export-json-api/configuration.js.map +1 -1
  96. package/esm/generated/export-json-api/index.d.ts.map +1 -1
  97. package/esm/generated/export-json-api/index.js +1 -0
  98. package/esm/generated/export-json-api/index.js.map +1 -1
  99. package/esm/generated/scan-json-api/api.d.ts +92 -92
  100. package/esm/generated/scan-json-api/api.d.ts.map +1 -1
  101. package/esm/generated/scan-json-api/api.js +115 -74
  102. package/esm/generated/scan-json-api/api.js.map +1 -1
  103. package/esm/generated/scan-json-api/base.d.ts +2 -2
  104. package/esm/generated/scan-json-api/base.d.ts.map +1 -1
  105. package/esm/generated/scan-json-api/base.js +3 -1
  106. package/esm/generated/scan-json-api/base.js.map +1 -1
  107. package/esm/generated/scan-json-api/common.d.ts +1 -1
  108. package/esm/generated/scan-json-api/common.d.ts.map +1 -1
  109. package/esm/generated/scan-json-api/common.js +24 -14
  110. package/esm/generated/scan-json-api/common.js.map +1 -1
  111. package/esm/generated/scan-json-api/configuration.d.ts.map +1 -1
  112. package/esm/generated/scan-json-api/configuration.js +3 -2
  113. package/esm/generated/scan-json-api/configuration.js.map +1 -1
  114. package/esm/generated/scan-json-api/index.d.ts.map +1 -1
  115. package/esm/generated/scan-json-api/index.js +1 -0
  116. package/esm/generated/scan-json-api/index.js.map +1 -1
  117. package/esm/index.d.ts +1 -1
  118. package/esm/index.d.ts.map +1 -1
  119. package/esm/index.js +1 -1
  120. package/esm/index.js.map +1 -1
  121. package/package.json +14 -8
@@ -1,5 +1,16 @@
1
- // (C) 2026 GoodData Corporation
2
- import globalAxios from "axios";
1
+ /* eslint-disable */
2
+ /**
3
+ * OpenAPI definition
4
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5
+ *
6
+ * The version of the OpenAPI document: v0
7
+ *
8
+ *
9
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
10
+ * https://openapi-generator.tech
11
+ * Do not edit the class manually.
12
+ */
13
+ import globalAxios from 'axios';
3
14
  // @ts-ignore
4
15
  import { DUMMY_BASE_URL, assertParamExists, setSearchParams, toPathString, createRequestFunction } from './common.js';
5
16
  // @ts-ignore
@@ -16,19 +27,20 @@ import { BASE_PATH, COLLECTION_FORMATS, BaseAPI } from './base.js';
16
27
  */
17
28
  export async function AILakeApiAxiosParamCreator_DeprovisionAiLakeDatabaseInstance(instanceId, operationId, options = {}, configuration) {
18
29
  // verify required parameter 'instanceId' is not null or undefined
19
- assertParamExists("deprovisionAiLakeDatabaseInstance", "instanceId", instanceId);
20
- const localVarPath = `/api/v1/ailake/database/instance/{instanceId}`.replace(`{${"instanceId"}}`, encodeURIComponent(String(instanceId)));
30
+ assertParamExists('deprovisionAiLakeDatabaseInstance', 'instanceId', instanceId);
31
+ const localVarPath = `/api/v1/ailake/database/instance/{instanceId}`
32
+ .replace(`{${"instanceId"}}`, encodeURIComponent(String(instanceId)));
21
33
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
22
34
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
23
35
  let baseOptions;
24
36
  if (configuration) {
25
37
  baseOptions = configuration.baseOptions;
26
38
  }
27
- const localVarRequestOptions = { method: "DELETE", ...baseOptions, ...options };
39
+ const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...options };
28
40
  const localVarHeaderParameter = {};
29
41
  const localVarQueryParameter = {};
30
42
  if (operationId !== undefined && operationId !== null) {
31
- localVarHeaderParameter["operation-id"] = String(operationId);
43
+ localVarHeaderParameter['operation-id'] = String(operationId);
32
44
  }
33
45
  setSearchParams(localVarUrlObj, localVarQueryParameter);
34
46
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -53,15 +65,16 @@ export async function AILakeApiAxiosParamCreator_DeprovisionAiLakeDatabaseInstan
53
65
  */
54
66
  export async function AILakeApiAxiosParamCreator_GetAiLakeDatabaseInstance(instanceId, options = {}, configuration) {
55
67
  // verify required parameter 'instanceId' is not null or undefined
56
- assertParamExists("getAiLakeDatabaseInstance", "instanceId", instanceId);
57
- const localVarPath = `/api/v1/ailake/database/instance/{instanceId}`.replace(`{${"instanceId"}}`, encodeURIComponent(String(instanceId)));
68
+ assertParamExists('getAiLakeDatabaseInstance', 'instanceId', instanceId);
69
+ const localVarPath = `/api/v1/ailake/database/instance/{instanceId}`
70
+ .replace(`{${"instanceId"}}`, encodeURIComponent(String(instanceId)));
58
71
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
59
72
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
60
73
  let baseOptions;
61
74
  if (configuration) {
62
75
  baseOptions = configuration.baseOptions;
63
76
  }
64
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
77
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
65
78
  const localVarHeaderParameter = {};
66
79
  const localVarQueryParameter = {};
67
80
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -87,15 +100,16 @@ export async function AILakeApiAxiosParamCreator_GetAiLakeDatabaseInstance(insta
87
100
  */
88
101
  export async function AILakeApiAxiosParamCreator_GetAiLakeOperation(operationId, options = {}, configuration) {
89
102
  // verify required parameter 'operationId' is not null or undefined
90
- assertParamExists("getAiLakeOperation", "operationId", operationId);
91
- const localVarPath = `/api/v1/ailake/operation/{operationId}`.replace(`{${"operationId"}}`, encodeURIComponent(String(operationId)));
103
+ assertParamExists('getAiLakeOperation', 'operationId', operationId);
104
+ const localVarPath = `/api/v1/ailake/operation/{operationId}`
105
+ .replace(`{${"operationId"}}`, encodeURIComponent(String(operationId)));
92
106
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
93
107
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
94
108
  let baseOptions;
95
109
  if (configuration) {
96
110
  baseOptions = configuration.baseOptions;
97
111
  }
98
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
112
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
99
113
  const localVarHeaderParameter = {};
100
114
  const localVarQueryParameter = {};
101
115
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -122,7 +136,7 @@ export async function AILakeApiAxiosParamCreator_GetAiLakeOperation(operationId,
122
136
  */
123
137
  export async function AILakeApiAxiosParamCreator_ProvisionAiLakeDatabaseInstance(provisionDatabaseInstanceRequest, operationId, options = {}, configuration) {
124
138
  // verify required parameter 'provisionDatabaseInstanceRequest' is not null or undefined
125
- assertParamExists("provisionAiLakeDatabaseInstance", "provisionDatabaseInstanceRequest", provisionDatabaseInstanceRequest);
139
+ assertParamExists('provisionAiLakeDatabaseInstance', 'provisionDatabaseInstanceRequest', provisionDatabaseInstanceRequest);
126
140
  const localVarPath = `/api/v1/ailake/database/instance`;
127
141
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
128
142
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -130,16 +144,18 @@ export async function AILakeApiAxiosParamCreator_ProvisionAiLakeDatabaseInstance
130
144
  if (configuration) {
131
145
  baseOptions = configuration.baseOptions;
132
146
  }
133
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
147
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
134
148
  const localVarHeaderParameter = {};
135
149
  const localVarQueryParameter = {};
136
150
  if (operationId !== undefined && operationId !== null) {
137
- localVarHeaderParameter["operation-id"] = String(operationId);
151
+ localVarHeaderParameter['operation-id'] = String(operationId);
138
152
  }
139
- const consumes = ["application/json"];
153
+ const consumes = [
154
+ 'application/json'
155
+ ];
140
156
  // use application/json if present, otherwise fallback to the first one
141
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
142
- ? "application/json"
157
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
158
+ ? 'application/json'
143
159
  : consumes[0];
144
160
  setSearchParams(localVarUrlObj, localVarQueryParameter);
145
161
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -282,23 +298,26 @@ export class AILakeApi extends BaseAPI {
282
298
  */
283
299
  export async function ActionsApiAxiosParamCreator_AiChat(workspaceId, chatRequest, options = {}, configuration) {
284
300
  // verify required parameter 'workspaceId' is not null or undefined
285
- assertParamExists("aiChat", "workspaceId", workspaceId);
301
+ assertParamExists('aiChat', 'workspaceId', workspaceId);
286
302
  // verify required parameter 'chatRequest' is not null or undefined
287
- assertParamExists("aiChat", "chatRequest", chatRequest);
288
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chat`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
303
+ assertParamExists('aiChat', 'chatRequest', chatRequest);
304
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chat`
305
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
289
306
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
290
307
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
291
308
  let baseOptions;
292
309
  if (configuration) {
293
310
  baseOptions = configuration.baseOptions;
294
311
  }
295
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
312
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
296
313
  const localVarHeaderParameter = {};
297
314
  const localVarQueryParameter = {};
298
- const consumes = ["application/json"];
315
+ const consumes = [
316
+ 'application/json'
317
+ ];
299
318
  // use application/json if present, otherwise fallback to the first one
300
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
301
- ? "application/json"
319
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
320
+ ? 'application/json'
302
321
  : consumes[0];
303
322
  setSearchParams(localVarUrlObj, localVarQueryParameter);
304
323
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -329,23 +348,26 @@ export async function ActionsApiAxiosParamCreator_AiChat(workspaceId, chatReques
329
348
  */
330
349
  export async function ActionsApiAxiosParamCreator_AiChatHistory(workspaceId, chatHistoryRequest, options = {}, configuration) {
331
350
  // verify required parameter 'workspaceId' is not null or undefined
332
- assertParamExists("aiChatHistory", "workspaceId", workspaceId);
351
+ assertParamExists('aiChatHistory', 'workspaceId', workspaceId);
333
352
  // verify required parameter 'chatHistoryRequest' is not null or undefined
334
- assertParamExists("aiChatHistory", "chatHistoryRequest", chatHistoryRequest);
335
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatHistory`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
353
+ assertParamExists('aiChatHistory', 'chatHistoryRequest', chatHistoryRequest);
354
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatHistory`
355
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
336
356
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
337
357
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
338
358
  let baseOptions;
339
359
  if (configuration) {
340
360
  baseOptions = configuration.baseOptions;
341
361
  }
342
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
362
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
343
363
  const localVarHeaderParameter = {};
344
364
  const localVarQueryParameter = {};
345
- const consumes = ["application/json"];
365
+ const consumes = [
366
+ 'application/json'
367
+ ];
346
368
  // use application/json if present, otherwise fallback to the first one
347
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
348
- ? "application/json"
369
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
370
+ ? 'application/json'
349
371
  : consumes[0];
350
372
  setSearchParams(localVarUrlObj, localVarQueryParameter);
351
373
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -376,23 +398,26 @@ export async function ActionsApiAxiosParamCreator_AiChatHistory(workspaceId, cha
376
398
  */
377
399
  export async function ActionsApiAxiosParamCreator_AiChatStream(workspaceId, chatRequest, options = {}, configuration) {
378
400
  // verify required parameter 'workspaceId' is not null or undefined
379
- assertParamExists("aiChatStream", "workspaceId", workspaceId);
401
+ assertParamExists('aiChatStream', 'workspaceId', workspaceId);
380
402
  // verify required parameter 'chatRequest' is not null or undefined
381
- assertParamExists("aiChatStream", "chatRequest", chatRequest);
382
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatStream`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
403
+ assertParamExists('aiChatStream', 'chatRequest', chatRequest);
404
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatStream`
405
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
383
406
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
384
407
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
385
408
  let baseOptions;
386
409
  if (configuration) {
387
410
  baseOptions = configuration.baseOptions;
388
411
  }
389
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
412
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
390
413
  const localVarHeaderParameter = {};
391
414
  const localVarQueryParameter = {};
392
- const consumes = ["application/json"];
415
+ const consumes = [
416
+ 'application/json'
417
+ ];
393
418
  // use application/json if present, otherwise fallback to the first one
394
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
395
- ? "application/json"
419
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
420
+ ? 'application/json'
396
421
  : consumes[0];
397
422
  setSearchParams(localVarUrlObj, localVarQueryParameter);
398
423
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -422,15 +447,16 @@ export async function ActionsApiAxiosParamCreator_AiChatStream(workspaceId, chat
422
447
  */
423
448
  export async function ActionsApiAxiosParamCreator_AiChatUsage(workspaceId, options = {}, configuration) {
424
449
  // verify required parameter 'workspaceId' is not null or undefined
425
- assertParamExists("aiChatUsage", "workspaceId", workspaceId);
426
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatUsage`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
450
+ assertParamExists('aiChatUsage', 'workspaceId', workspaceId);
451
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatUsage`
452
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
427
453
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
428
454
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
429
455
  let baseOptions;
430
456
  if (configuration) {
431
457
  baseOptions = configuration.baseOptions;
432
458
  }
433
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
459
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
434
460
  const localVarHeaderParameter = {};
435
461
  const localVarQueryParameter = {};
436
462
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -457,23 +483,26 @@ export async function ActionsApiAxiosParamCreator_AiChatUsage(workspaceId, optio
457
483
  */
458
484
  export async function ActionsApiAxiosParamCreator_AiSearch(workspaceId, searchRequest, options = {}, configuration) {
459
485
  // verify required parameter 'workspaceId' is not null or undefined
460
- assertParamExists("aiSearch", "workspaceId", workspaceId);
486
+ assertParamExists('aiSearch', 'workspaceId', workspaceId);
461
487
  // verify required parameter 'searchRequest' is not null or undefined
462
- assertParamExists("aiSearch", "searchRequest", searchRequest);
463
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/search`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
488
+ assertParamExists('aiSearch', 'searchRequest', searchRequest);
489
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/search`
490
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
464
491
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
465
492
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
466
493
  let baseOptions;
467
494
  if (configuration) {
468
495
  baseOptions = configuration.baseOptions;
469
496
  }
470
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
497
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
471
498
  const localVarHeaderParameter = {};
472
499
  const localVarQueryParameter = {};
473
- const consumes = ["application/json"];
500
+ const consumes = [
501
+ 'application/json'
502
+ ];
474
503
  // use application/json if present, otherwise fallback to the first one
475
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
476
- ? "application/json"
504
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
505
+ ? 'application/json'
477
506
  : consumes[0];
478
507
  setSearchParams(localVarUrlObj, localVarQueryParameter);
479
508
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -506,11 +535,11 @@ export async function ActionsApiAxiosParamCreator_AiSearch(workspaceId, searchRe
506
535
  */
507
536
  export async function ActionsApiAxiosParamCreator_AnomalyDetection(workspaceId, resultId, anomalyDetectionRequest, skipCache, options = {}, configuration) {
508
537
  // verify required parameter 'workspaceId' is not null or undefined
509
- assertParamExists("anomalyDetection", "workspaceId", workspaceId);
538
+ assertParamExists('anomalyDetection', 'workspaceId', workspaceId);
510
539
  // verify required parameter 'resultId' is not null or undefined
511
- assertParamExists("anomalyDetection", "resultId", resultId);
540
+ assertParamExists('anomalyDetection', 'resultId', resultId);
512
541
  // verify required parameter 'anomalyDetectionRequest' is not null or undefined
513
- assertParamExists("anomalyDetection", "anomalyDetectionRequest", anomalyDetectionRequest);
542
+ assertParamExists('anomalyDetection', 'anomalyDetectionRequest', anomalyDetectionRequest);
514
543
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/anomalyDetection/{resultId}`
515
544
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
516
545
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -520,16 +549,18 @@ export async function ActionsApiAxiosParamCreator_AnomalyDetection(workspaceId,
520
549
  if (configuration) {
521
550
  baseOptions = configuration.baseOptions;
522
551
  }
523
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
552
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
524
553
  const localVarHeaderParameter = {};
525
554
  const localVarQueryParameter = {};
526
555
  if (skipCache !== undefined && skipCache !== null) {
527
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
556
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
528
557
  }
529
- const consumes = ["application/json"];
558
+ const consumes = [
559
+ 'application/json'
560
+ ];
530
561
  // use application/json if present, otherwise fallback to the first one
531
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
532
- ? "application/json"
562
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
563
+ ? 'application/json'
533
564
  : consumes[0];
534
565
  setSearchParams(localVarUrlObj, localVarQueryParameter);
535
566
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -562,9 +593,9 @@ export async function ActionsApiAxiosParamCreator_AnomalyDetection(workspaceId,
562
593
  */
563
594
  export async function ActionsApiAxiosParamCreator_AnomalyDetectionResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
564
595
  // verify required parameter 'workspaceId' is not null or undefined
565
- assertParamExists("anomalyDetectionResult", "workspaceId", workspaceId);
596
+ assertParamExists('anomalyDetectionResult', 'workspaceId', workspaceId);
566
597
  // verify required parameter 'resultId' is not null or undefined
567
- assertParamExists("anomalyDetectionResult", "resultId", resultId);
598
+ assertParamExists('anomalyDetectionResult', 'resultId', resultId);
568
599
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/anomalyDetection/result/{resultId}`
569
600
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
570
601
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -574,14 +605,14 @@ export async function ActionsApiAxiosParamCreator_AnomalyDetectionResult(workspa
574
605
  if (configuration) {
575
606
  baseOptions = configuration.baseOptions;
576
607
  }
577
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
608
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
578
609
  const localVarHeaderParameter = {};
579
610
  const localVarQueryParameter = {};
580
611
  if (offset !== undefined) {
581
- localVarQueryParameter["offset"] = offset;
612
+ localVarQueryParameter['offset'] = offset;
582
613
  }
583
614
  if (limit !== undefined) {
584
- localVarQueryParameter["limit"] = limit;
615
+ localVarQueryParameter['limit'] = limit;
585
616
  }
586
617
  setSearchParams(localVarUrlObj, localVarQueryParameter);
587
618
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -607,23 +638,26 @@ export async function ActionsApiAxiosParamCreator_AnomalyDetectionResult(workspa
607
638
  */
608
639
  export async function ActionsApiAxiosParamCreator_CancelExecutions(workspaceId, afmCancelTokens, options = {}, configuration) {
609
640
  // verify required parameter 'workspaceId' is not null or undefined
610
- assertParamExists("cancelExecutions", "workspaceId", workspaceId);
641
+ assertParamExists('cancelExecutions', 'workspaceId', workspaceId);
611
642
  // verify required parameter 'afmCancelTokens' is not null or undefined
612
- assertParamExists("cancelExecutions", "afmCancelTokens", afmCancelTokens);
613
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/cancel`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
643
+ assertParamExists('cancelExecutions', 'afmCancelTokens', afmCancelTokens);
644
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/cancel`
645
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
614
646
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
615
647
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
616
648
  let baseOptions;
617
649
  if (configuration) {
618
650
  baseOptions = configuration.baseOptions;
619
651
  }
620
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
652
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
621
653
  const localVarHeaderParameter = {};
622
654
  const localVarQueryParameter = {};
623
- const consumes = ["application/json"];
655
+ const consumes = [
656
+ 'application/json'
657
+ ];
624
658
  // use application/json if present, otherwise fallback to the first one
625
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
626
- ? "application/json"
659
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
660
+ ? 'application/json'
627
661
  : consumes[0];
628
662
  setSearchParams(localVarUrlObj, localVarQueryParameter);
629
663
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -654,23 +688,26 @@ export async function ActionsApiAxiosParamCreator_CancelExecutions(workspaceId,
654
688
  */
655
689
  export async function ActionsApiAxiosParamCreator_ChangeAnalysis(workspaceId, changeAnalysisRequest, options = {}, configuration) {
656
690
  // verify required parameter 'workspaceId' is not null or undefined
657
- assertParamExists("changeAnalysis", "workspaceId", workspaceId);
691
+ assertParamExists('changeAnalysis', 'workspaceId', workspaceId);
658
692
  // verify required parameter 'changeAnalysisRequest' is not null or undefined
659
- assertParamExists("changeAnalysis", "changeAnalysisRequest", changeAnalysisRequest);
660
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeChangeAnalysis`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
693
+ assertParamExists('changeAnalysis', 'changeAnalysisRequest', changeAnalysisRequest);
694
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeChangeAnalysis`
695
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
661
696
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
662
697
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
663
698
  let baseOptions;
664
699
  if (configuration) {
665
700
  baseOptions = configuration.baseOptions;
666
701
  }
667
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
702
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
668
703
  const localVarHeaderParameter = {};
669
704
  const localVarQueryParameter = {};
670
- const consumes = ["application/json"];
705
+ const consumes = [
706
+ 'application/json'
707
+ ];
671
708
  // use application/json if present, otherwise fallback to the first one
672
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
673
- ? "application/json"
709
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
710
+ ? 'application/json'
674
711
  : consumes[0];
675
712
  setSearchParams(localVarUrlObj, localVarQueryParameter);
676
713
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -701,9 +738,9 @@ export async function ActionsApiAxiosParamCreator_ChangeAnalysis(workspaceId, ch
701
738
  */
702
739
  export async function ActionsApiAxiosParamCreator_ChangeAnalysisResult(workspaceId, resultId, options = {}, configuration) {
703
740
  // verify required parameter 'workspaceId' is not null or undefined
704
- assertParamExists("changeAnalysisResult", "workspaceId", workspaceId);
741
+ assertParamExists('changeAnalysisResult', 'workspaceId', workspaceId);
705
742
  // verify required parameter 'resultId' is not null or undefined
706
- assertParamExists("changeAnalysisResult", "resultId", resultId);
743
+ assertParamExists('changeAnalysisResult', 'resultId', resultId);
707
744
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeChangeAnalysis/result/{resultId}`
708
745
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
709
746
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -713,7 +750,7 @@ export async function ActionsApiAxiosParamCreator_ChangeAnalysisResult(workspace
713
750
  if (configuration) {
714
751
  baseOptions = configuration.baseOptions;
715
752
  }
716
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
753
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
717
754
  const localVarHeaderParameter = {};
718
755
  const localVarQueryParameter = {};
719
756
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -742,11 +779,11 @@ export async function ActionsApiAxiosParamCreator_ChangeAnalysisResult(workspace
742
779
  */
743
780
  export async function ActionsApiAxiosParamCreator_Clustering(workspaceId, resultId, clusteringRequest, skipCache, options = {}, configuration) {
744
781
  // verify required parameter 'workspaceId' is not null or undefined
745
- assertParamExists("clustering", "workspaceId", workspaceId);
782
+ assertParamExists('clustering', 'workspaceId', workspaceId);
746
783
  // verify required parameter 'resultId' is not null or undefined
747
- assertParamExists("clustering", "resultId", resultId);
784
+ assertParamExists('clustering', 'resultId', resultId);
748
785
  // verify required parameter 'clusteringRequest' is not null or undefined
749
- assertParamExists("clustering", "clusteringRequest", clusteringRequest);
786
+ assertParamExists('clustering', 'clusteringRequest', clusteringRequest);
750
787
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/clustering/{resultId}`
751
788
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
752
789
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -756,16 +793,18 @@ export async function ActionsApiAxiosParamCreator_Clustering(workspaceId, result
756
793
  if (configuration) {
757
794
  baseOptions = configuration.baseOptions;
758
795
  }
759
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
796
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
760
797
  const localVarHeaderParameter = {};
761
798
  const localVarQueryParameter = {};
762
799
  if (skipCache !== undefined && skipCache !== null) {
763
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
800
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
764
801
  }
765
- const consumes = ["application/json"];
802
+ const consumes = [
803
+ 'application/json'
804
+ ];
766
805
  // use application/json if present, otherwise fallback to the first one
767
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
768
- ? "application/json"
806
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
807
+ ? 'application/json'
769
808
  : consumes[0];
770
809
  setSearchParams(localVarUrlObj, localVarQueryParameter);
771
810
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -798,9 +837,9 @@ export async function ActionsApiAxiosParamCreator_Clustering(workspaceId, result
798
837
  */
799
838
  export async function ActionsApiAxiosParamCreator_ClusteringResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
800
839
  // verify required parameter 'workspaceId' is not null or undefined
801
- assertParamExists("clusteringResult", "workspaceId", workspaceId);
840
+ assertParamExists('clusteringResult', 'workspaceId', workspaceId);
802
841
  // verify required parameter 'resultId' is not null or undefined
803
- assertParamExists("clusteringResult", "resultId", resultId);
842
+ assertParamExists('clusteringResult', 'resultId', resultId);
804
843
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/clustering/result/{resultId}`
805
844
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
806
845
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -810,14 +849,14 @@ export async function ActionsApiAxiosParamCreator_ClusteringResult(workspaceId,
810
849
  if (configuration) {
811
850
  baseOptions = configuration.baseOptions;
812
851
  }
813
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
852
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
814
853
  const localVarHeaderParameter = {};
815
854
  const localVarQueryParameter = {};
816
855
  if (offset !== undefined) {
817
- localVarQueryParameter["offset"] = offset;
856
+ localVarQueryParameter['offset'] = offset;
818
857
  }
819
858
  if (limit !== undefined) {
820
- localVarQueryParameter["limit"] = limit;
859
+ localVarQueryParameter['limit'] = limit;
821
860
  }
822
861
  setSearchParams(localVarUrlObj, localVarQueryParameter);
823
862
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -846,32 +885,35 @@ export async function ActionsApiAxiosParamCreator_ClusteringResult(workspaceId,
846
885
  */
847
886
  export async function ActionsApiAxiosParamCreator_ComputeLabelElementsPost(workspaceId, elementsRequest, offset, limit, skipCache, options = {}, configuration) {
848
887
  // verify required parameter 'workspaceId' is not null or undefined
849
- assertParamExists("computeLabelElementsPost", "workspaceId", workspaceId);
888
+ assertParamExists('computeLabelElementsPost', 'workspaceId', workspaceId);
850
889
  // verify required parameter 'elementsRequest' is not null or undefined
851
- assertParamExists("computeLabelElementsPost", "elementsRequest", elementsRequest);
852
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/collectLabelElements`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
890
+ assertParamExists('computeLabelElementsPost', 'elementsRequest', elementsRequest);
891
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/collectLabelElements`
892
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
853
893
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
854
894
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
855
895
  let baseOptions;
856
896
  if (configuration) {
857
897
  baseOptions = configuration.baseOptions;
858
898
  }
859
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
899
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
860
900
  const localVarHeaderParameter = {};
861
901
  const localVarQueryParameter = {};
862
902
  if (offset !== undefined) {
863
- localVarQueryParameter["offset"] = offset;
903
+ localVarQueryParameter['offset'] = offset;
864
904
  }
865
905
  if (limit !== undefined) {
866
- localVarQueryParameter["limit"] = limit;
906
+ localVarQueryParameter['limit'] = limit;
867
907
  }
868
908
  if (skipCache !== undefined && skipCache !== null) {
869
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
909
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
870
910
  }
871
- const consumes = ["application/json"];
911
+ const consumes = [
912
+ 'application/json'
913
+ ];
872
914
  // use application/json if present, otherwise fallback to the first one
873
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
874
- ? "application/json"
915
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
916
+ ? 'application/json'
875
917
  : consumes[0];
876
918
  setSearchParams(localVarUrlObj, localVarQueryParameter);
877
919
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -904,29 +946,32 @@ export async function ActionsApiAxiosParamCreator_ComputeLabelElementsPost(works
904
946
  */
905
947
  export async function ActionsApiAxiosParamCreator_ComputeReport(workspaceId, afmExecution, skipCache, timestamp, options = {}, configuration) {
906
948
  // verify required parameter 'workspaceId' is not null or undefined
907
- assertParamExists("computeReport", "workspaceId", workspaceId);
949
+ assertParamExists('computeReport', 'workspaceId', workspaceId);
908
950
  // verify required parameter 'afmExecution' is not null or undefined
909
- assertParamExists("computeReport", "afmExecution", afmExecution);
910
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
951
+ assertParamExists('computeReport', 'afmExecution', afmExecution);
952
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute`
953
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
911
954
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
912
955
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
913
956
  let baseOptions;
914
957
  if (configuration) {
915
958
  baseOptions = configuration.baseOptions;
916
959
  }
917
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
960
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
918
961
  const localVarHeaderParameter = {};
919
962
  const localVarQueryParameter = {};
920
963
  if (skipCache !== undefined && skipCache !== null) {
921
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
964
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
922
965
  }
923
966
  if (timestamp !== undefined && timestamp !== null) {
924
- localVarHeaderParameter["timestamp"] = String(timestamp);
967
+ localVarHeaderParameter['timestamp'] = String(timestamp);
925
968
  }
926
- const consumes = ["application/json"];
969
+ const consumes = [
970
+ 'application/json'
971
+ ];
927
972
  // use application/json if present, otherwise fallback to the first one
928
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
929
- ? "application/json"
973
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
974
+ ? 'application/json'
930
975
  : consumes[0];
931
976
  setSearchParams(localVarUrlObj, localVarQueryParameter);
932
977
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -957,23 +1002,26 @@ export async function ActionsApiAxiosParamCreator_ComputeReport(workspaceId, afm
957
1002
  */
958
1003
  export async function ActionsApiAxiosParamCreator_ComputeValidDescendants(workspaceId, afmValidDescendantsQuery, options = {}, configuration) {
959
1004
  // verify required parameter 'workspaceId' is not null or undefined
960
- assertParamExists("computeValidDescendants", "workspaceId", workspaceId);
1005
+ assertParamExists('computeValidDescendants', 'workspaceId', workspaceId);
961
1006
  // verify required parameter 'afmValidDescendantsQuery' is not null or undefined
962
- assertParamExists("computeValidDescendants", "afmValidDescendantsQuery", afmValidDescendantsQuery);
963
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidDescendants`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1007
+ assertParamExists('computeValidDescendants', 'afmValidDescendantsQuery', afmValidDescendantsQuery);
1008
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidDescendants`
1009
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
964
1010
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
965
1011
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
966
1012
  let baseOptions;
967
1013
  if (configuration) {
968
1014
  baseOptions = configuration.baseOptions;
969
1015
  }
970
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1016
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
971
1017
  const localVarHeaderParameter = {};
972
1018
  const localVarQueryParameter = {};
973
- const consumes = ["application/json"];
1019
+ const consumes = [
1020
+ 'application/json'
1021
+ ];
974
1022
  // use application/json if present, otherwise fallback to the first one
975
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
976
- ? "application/json"
1023
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1024
+ ? 'application/json'
977
1025
  : consumes[0];
978
1026
  setSearchParams(localVarUrlObj, localVarQueryParameter);
979
1027
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1004,23 +1052,26 @@ export async function ActionsApiAxiosParamCreator_ComputeValidDescendants(worksp
1004
1052
  */
1005
1053
  export async function ActionsApiAxiosParamCreator_ComputeValidObjects(workspaceId, afmValidObjectsQuery, options = {}, configuration) {
1006
1054
  // verify required parameter 'workspaceId' is not null or undefined
1007
- assertParamExists("computeValidObjects", "workspaceId", workspaceId);
1055
+ assertParamExists('computeValidObjects', 'workspaceId', workspaceId);
1008
1056
  // verify required parameter 'afmValidObjectsQuery' is not null or undefined
1009
- assertParamExists("computeValidObjects", "afmValidObjectsQuery", afmValidObjectsQuery);
1010
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidObjects`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1057
+ assertParamExists('computeValidObjects', 'afmValidObjectsQuery', afmValidObjectsQuery);
1058
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidObjects`
1059
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1011
1060
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1012
1061
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1013
1062
  let baseOptions;
1014
1063
  if (configuration) {
1015
1064
  baseOptions = configuration.baseOptions;
1016
1065
  }
1017
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1066
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1018
1067
  const localVarHeaderParameter = {};
1019
1068
  const localVarQueryParameter = {};
1020
- const consumes = ["application/json"];
1069
+ const consumes = [
1070
+ 'application/json'
1071
+ ];
1021
1072
  // use application/json if present, otherwise fallback to the first one
1022
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
1023
- ? "application/json"
1073
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1074
+ ? 'application/json'
1024
1075
  : consumes[0];
1025
1076
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1026
1077
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1050,15 +1101,16 @@ export async function ActionsApiAxiosParamCreator_ComputeValidObjects(workspaceI
1050
1101
  */
1051
1102
  export async function ActionsApiAxiosParamCreator_CreatedBy(workspaceId, options = {}, configuration) {
1052
1103
  // verify required parameter 'workspaceId' is not null or undefined
1053
- assertParamExists("createdBy", "workspaceId", workspaceId);
1054
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/createdBy`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1104
+ assertParamExists('createdBy', 'workspaceId', workspaceId);
1105
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/createdBy`
1106
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1055
1107
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1056
1108
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1057
1109
  let baseOptions;
1058
1110
  if (configuration) {
1059
1111
  baseOptions = configuration.baseOptions;
1060
1112
  }
1061
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1113
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1062
1114
  const localVarHeaderParameter = {};
1063
1115
  const localVarQueryParameter = {};
1064
1116
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1086,26 +1138,29 @@ export async function ActionsApiAxiosParamCreator_CreatedBy(workspaceId, options
1086
1138
  */
1087
1139
  export async function ActionsApiAxiosParamCreator_ExplainAFM(workspaceId, afmExecution, explainType, options = {}, configuration) {
1088
1140
  // verify required parameter 'workspaceId' is not null or undefined
1089
- assertParamExists("explainAFM", "workspaceId", workspaceId);
1141
+ assertParamExists('explainAFM', 'workspaceId', workspaceId);
1090
1142
  // verify required parameter 'afmExecution' is not null or undefined
1091
- assertParamExists("explainAFM", "afmExecution", afmExecution);
1092
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/explain`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1143
+ assertParamExists('explainAFM', 'afmExecution', afmExecution);
1144
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/explain`
1145
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1093
1146
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1094
1147
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1095
1148
  let baseOptions;
1096
1149
  if (configuration) {
1097
1150
  baseOptions = configuration.baseOptions;
1098
1151
  }
1099
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1152
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1100
1153
  const localVarHeaderParameter = {};
1101
1154
  const localVarQueryParameter = {};
1102
1155
  if (explainType !== undefined) {
1103
- localVarQueryParameter["explainType"] = explainType;
1156
+ localVarQueryParameter['explainType'] = explainType;
1104
1157
  }
1105
- const consumes = ["application/json"];
1158
+ const consumes = [
1159
+ 'application/json'
1160
+ ];
1106
1161
  // use application/json if present, otherwise fallback to the first one
1107
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
1108
- ? "application/json"
1162
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1163
+ ? 'application/json'
1109
1164
  : consumes[0];
1110
1165
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1111
1166
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1138,11 +1193,11 @@ export async function ActionsApiAxiosParamCreator_ExplainAFM(workspaceId, afmExe
1138
1193
  */
1139
1194
  export async function ActionsApiAxiosParamCreator_Forecast(workspaceId, resultId, forecastRequest, skipCache, options = {}, configuration) {
1140
1195
  // verify required parameter 'workspaceId' is not null or undefined
1141
- assertParamExists("forecast", "workspaceId", workspaceId);
1196
+ assertParamExists('forecast', 'workspaceId', workspaceId);
1142
1197
  // verify required parameter 'resultId' is not null or undefined
1143
- assertParamExists("forecast", "resultId", resultId);
1198
+ assertParamExists('forecast', 'resultId', resultId);
1144
1199
  // verify required parameter 'forecastRequest' is not null or undefined
1145
- assertParamExists("forecast", "forecastRequest", forecastRequest);
1200
+ assertParamExists('forecast', 'forecastRequest', forecastRequest);
1146
1201
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/forecast/{resultId}`
1147
1202
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
1148
1203
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -1152,16 +1207,18 @@ export async function ActionsApiAxiosParamCreator_Forecast(workspaceId, resultId
1152
1207
  if (configuration) {
1153
1208
  baseOptions = configuration.baseOptions;
1154
1209
  }
1155
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1210
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1156
1211
  const localVarHeaderParameter = {};
1157
1212
  const localVarQueryParameter = {};
1158
1213
  if (skipCache !== undefined && skipCache !== null) {
1159
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
1214
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
1160
1215
  }
1161
- const consumes = ["application/json"];
1216
+ const consumes = [
1217
+ 'application/json'
1218
+ ];
1162
1219
  // use application/json if present, otherwise fallback to the first one
1163
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
1164
- ? "application/json"
1220
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1221
+ ? 'application/json'
1165
1222
  : consumes[0];
1166
1223
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1167
1224
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1194,9 +1251,9 @@ export async function ActionsApiAxiosParamCreator_Forecast(workspaceId, resultId
1194
1251
  */
1195
1252
  export async function ActionsApiAxiosParamCreator_ForecastResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
1196
1253
  // verify required parameter 'workspaceId' is not null or undefined
1197
- assertParamExists("forecastResult", "workspaceId", workspaceId);
1254
+ assertParamExists('forecastResult', 'workspaceId', workspaceId);
1198
1255
  // verify required parameter 'resultId' is not null or undefined
1199
- assertParamExists("forecastResult", "resultId", resultId);
1256
+ assertParamExists('forecastResult', 'resultId', resultId);
1200
1257
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/forecast/result/{resultId}`
1201
1258
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
1202
1259
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -1206,14 +1263,14 @@ export async function ActionsApiAxiosParamCreator_ForecastResult(workspaceId, re
1206
1263
  if (configuration) {
1207
1264
  baseOptions = configuration.baseOptions;
1208
1265
  }
1209
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1266
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1210
1267
  const localVarHeaderParameter = {};
1211
1268
  const localVarQueryParameter = {};
1212
1269
  if (offset !== undefined) {
1213
- localVarQueryParameter["offset"] = offset;
1270
+ localVarQueryParameter['offset'] = offset;
1214
1271
  }
1215
1272
  if (limit !== undefined) {
1216
- localVarQueryParameter["limit"] = limit;
1273
+ localVarQueryParameter['limit'] = limit;
1217
1274
  }
1218
1275
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1219
1276
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1238,15 +1295,16 @@ export async function ActionsApiAxiosParamCreator_ForecastResult(workspaceId, re
1238
1295
  */
1239
1296
  export async function ActionsApiAxiosParamCreator_GetQualityIssues(workspaceId, options = {}, configuration) {
1240
1297
  // verify required parameter 'workspaceId' is not null or undefined
1241
- assertParamExists("getQualityIssues", "workspaceId", workspaceId);
1242
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1298
+ assertParamExists('getQualityIssues', 'workspaceId', workspaceId);
1299
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues`
1300
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1243
1301
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1244
1302
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1245
1303
  let baseOptions;
1246
1304
  if (configuration) {
1247
1305
  baseOptions = configuration.baseOptions;
1248
1306
  }
1249
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1307
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1250
1308
  const localVarHeaderParameter = {};
1251
1309
  const localVarQueryParameter = {};
1252
1310
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1273,9 +1331,9 @@ export async function ActionsApiAxiosParamCreator_GetQualityIssues(workspaceId,
1273
1331
  */
1274
1332
  export async function ActionsApiAxiosParamCreator_GetQualityIssuesCalculationStatus(workspaceId, processId, options = {}, configuration) {
1275
1333
  // verify required parameter 'workspaceId' is not null or undefined
1276
- assertParamExists("getQualityIssuesCalculationStatus", "workspaceId", workspaceId);
1334
+ assertParamExists('getQualityIssuesCalculationStatus', 'workspaceId', workspaceId);
1277
1335
  // verify required parameter 'processId' is not null or undefined
1278
- assertParamExists("getQualityIssuesCalculationStatus", "processId", processId);
1336
+ assertParamExists('getQualityIssuesCalculationStatus', 'processId', processId);
1279
1337
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues/status/{processId}`
1280
1338
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
1281
1339
  .replace(`{${"processId"}}`, encodeURIComponent(String(processId)));
@@ -1285,7 +1343,7 @@ export async function ActionsApiAxiosParamCreator_GetQualityIssuesCalculationSta
1285
1343
  if (configuration) {
1286
1344
  baseOptions = configuration.baseOptions;
1287
1345
  }
1288
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1346
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1289
1347
  const localVarHeaderParameter = {};
1290
1348
  const localVarQueryParameter = {};
1291
1349
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1313,26 +1371,29 @@ export async function ActionsApiAxiosParamCreator_GetQualityIssuesCalculationSta
1313
1371
  */
1314
1372
  export async function ActionsApiAxiosParamCreator_KeyDriverAnalysis(workspaceId, keyDriversRequest, skipCache, options = {}, configuration) {
1315
1373
  // verify required parameter 'workspaceId' is not null or undefined
1316
- assertParamExists("keyDriverAnalysis", "workspaceId", workspaceId);
1374
+ assertParamExists('keyDriverAnalysis', 'workspaceId', workspaceId);
1317
1375
  // verify required parameter 'keyDriversRequest' is not null or undefined
1318
- assertParamExists("keyDriverAnalysis", "keyDriversRequest", keyDriversRequest);
1319
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeKeyDrivers`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1376
+ assertParamExists('keyDriverAnalysis', 'keyDriversRequest', keyDriversRequest);
1377
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeKeyDrivers`
1378
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1320
1379
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1321
1380
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1322
1381
  let baseOptions;
1323
1382
  if (configuration) {
1324
1383
  baseOptions = configuration.baseOptions;
1325
1384
  }
1326
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1385
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1327
1386
  const localVarHeaderParameter = {};
1328
1387
  const localVarQueryParameter = {};
1329
1388
  if (skipCache !== undefined && skipCache !== null) {
1330
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
1389
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
1331
1390
  }
1332
- const consumes = ["application/json"];
1391
+ const consumes = [
1392
+ 'application/json'
1393
+ ];
1333
1394
  // use application/json if present, otherwise fallback to the first one
1334
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
1335
- ? "application/json"
1395
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1396
+ ? 'application/json'
1336
1397
  : consumes[0];
1337
1398
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1338
1399
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1365,9 +1426,9 @@ export async function ActionsApiAxiosParamCreator_KeyDriverAnalysis(workspaceId,
1365
1426
  */
1366
1427
  export async function ActionsApiAxiosParamCreator_KeyDriverAnalysisResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
1367
1428
  // verify required parameter 'workspaceId' is not null or undefined
1368
- assertParamExists("keyDriverAnalysisResult", "workspaceId", workspaceId);
1429
+ assertParamExists('keyDriverAnalysisResult', 'workspaceId', workspaceId);
1369
1430
  // verify required parameter 'resultId' is not null or undefined
1370
- assertParamExists("keyDriverAnalysisResult", "resultId", resultId);
1431
+ assertParamExists('keyDriverAnalysisResult', 'resultId', resultId);
1371
1432
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeKeyDrivers/result/{resultId}`
1372
1433
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
1373
1434
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -1377,14 +1438,14 @@ export async function ActionsApiAxiosParamCreator_KeyDriverAnalysisResult(worksp
1377
1438
  if (configuration) {
1378
1439
  baseOptions = configuration.baseOptions;
1379
1440
  }
1380
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1441
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1381
1442
  const localVarHeaderParameter = {};
1382
1443
  const localVarQueryParameter = {};
1383
1444
  if (offset !== undefined) {
1384
- localVarQueryParameter["offset"] = offset;
1445
+ localVarQueryParameter['offset'] = offset;
1385
1446
  }
1386
1447
  if (limit !== undefined) {
1387
- localVarQueryParameter["limit"] = limit;
1448
+ localVarQueryParameter['limit'] = limit;
1388
1449
  }
1389
1450
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1390
1451
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1409,15 +1470,16 @@ export async function ActionsApiAxiosParamCreator_KeyDriverAnalysisResult(worksp
1409
1470
  */
1410
1471
  export async function ActionsApiAxiosParamCreator_MemoryCreatedByUsers(workspaceId, options = {}, configuration) {
1411
1472
  // verify required parameter 'workspaceId' is not null or undefined
1412
- assertParamExists("memoryCreatedByUsers", "workspaceId", workspaceId);
1413
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/memory/createdBy`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1473
+ assertParamExists('memoryCreatedByUsers', 'workspaceId', workspaceId);
1474
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/memory/createdBy`
1475
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1414
1476
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1415
1477
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1416
1478
  let baseOptions;
1417
1479
  if (configuration) {
1418
1480
  baseOptions = configuration.baseOptions;
1419
1481
  }
1420
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1482
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1421
1483
  const localVarHeaderParameter = {};
1422
1484
  const localVarQueryParameter = {};
1423
1485
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1445,26 +1507,29 @@ export async function ActionsApiAxiosParamCreator_MemoryCreatedByUsers(workspace
1445
1507
  */
1446
1508
  export async function ActionsApiAxiosParamCreator_OutlierDetection(workspaceId, outlierDetectionRequest, skipCache, options = {}, configuration) {
1447
1509
  // verify required parameter 'workspaceId' is not null or undefined
1448
- assertParamExists("outlierDetection", "workspaceId", workspaceId);
1510
+ assertParamExists('outlierDetection', 'workspaceId', workspaceId);
1449
1511
  // verify required parameter 'outlierDetectionRequest' is not null or undefined
1450
- assertParamExists("outlierDetection", "outlierDetectionRequest", outlierDetectionRequest);
1451
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/detectOutliers`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1512
+ assertParamExists('outlierDetection', 'outlierDetectionRequest', outlierDetectionRequest);
1513
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/detectOutliers`
1514
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1452
1515
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1453
1516
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1454
1517
  let baseOptions;
1455
1518
  if (configuration) {
1456
1519
  baseOptions = configuration.baseOptions;
1457
1520
  }
1458
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1521
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1459
1522
  const localVarHeaderParameter = {};
1460
1523
  const localVarQueryParameter = {};
1461
1524
  if (skipCache !== undefined && skipCache !== null) {
1462
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
1525
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
1463
1526
  }
1464
- const consumes = ["application/json"];
1527
+ const consumes = [
1528
+ 'application/json'
1529
+ ];
1465
1530
  // use application/json if present, otherwise fallback to the first one
1466
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
1467
- ? "application/json"
1531
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1532
+ ? 'application/json'
1468
1533
  : consumes[0];
1469
1534
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1470
1535
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1497,9 +1562,9 @@ export async function ActionsApiAxiosParamCreator_OutlierDetection(workspaceId,
1497
1562
  */
1498
1563
  export async function ActionsApiAxiosParamCreator_OutlierDetectionResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
1499
1564
  // verify required parameter 'workspaceId' is not null or undefined
1500
- assertParamExists("outlierDetectionResult", "workspaceId", workspaceId);
1565
+ assertParamExists('outlierDetectionResult', 'workspaceId', workspaceId);
1501
1566
  // verify required parameter 'resultId' is not null or undefined
1502
- assertParamExists("outlierDetectionResult", "resultId", resultId);
1567
+ assertParamExists('outlierDetectionResult', 'resultId', resultId);
1503
1568
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/detectOutliers/result/{resultId}`
1504
1569
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
1505
1570
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -1509,14 +1574,14 @@ export async function ActionsApiAxiosParamCreator_OutlierDetectionResult(workspa
1509
1574
  if (configuration) {
1510
1575
  baseOptions = configuration.baseOptions;
1511
1576
  }
1512
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1577
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1513
1578
  const localVarHeaderParameter = {};
1514
1579
  const localVarQueryParameter = {};
1515
1580
  if (offset !== undefined) {
1516
- localVarQueryParameter["offset"] = offset;
1581
+ localVarQueryParameter['offset'] = offset;
1517
1582
  }
1518
1583
  if (limit !== undefined) {
1519
- localVarQueryParameter["limit"] = limit;
1584
+ localVarQueryParameter['limit'] = limit;
1520
1585
  }
1521
1586
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1522
1587
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1541,15 +1606,16 @@ export async function ActionsApiAxiosParamCreator_OutlierDetectionResult(workspa
1541
1606
  */
1542
1607
  export async function ActionsApiAxiosParamCreator_ResolveLlmEndpoints(workspaceId, options = {}, configuration) {
1543
1608
  // verify required parameter 'workspaceId' is not null or undefined
1544
- assertParamExists("resolveLlmEndpoints", "workspaceId", workspaceId);
1545
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/resolveLlmEndpoints`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1609
+ assertParamExists('resolveLlmEndpoints', 'workspaceId', workspaceId);
1610
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/resolveLlmEndpoints`
1611
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1546
1612
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1547
1613
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1548
1614
  let baseOptions;
1549
1615
  if (configuration) {
1550
1616
  baseOptions = configuration.baseOptions;
1551
1617
  }
1552
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1618
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1553
1619
  const localVarHeaderParameter = {};
1554
1620
  const localVarQueryParameter = {};
1555
1621
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1576,9 +1642,9 @@ export async function ActionsApiAxiosParamCreator_ResolveLlmEndpoints(workspaceI
1576
1642
  */
1577
1643
  export async function ActionsApiAxiosParamCreator_RetrieveExecutionMetadata(workspaceId, resultId, options = {}, configuration) {
1578
1644
  // verify required parameter 'workspaceId' is not null or undefined
1579
- assertParamExists("retrieveExecutionMetadata", "workspaceId", workspaceId);
1645
+ assertParamExists('retrieveExecutionMetadata', 'workspaceId', workspaceId);
1580
1646
  // verify required parameter 'resultId' is not null or undefined
1581
- assertParamExists("retrieveExecutionMetadata", "resultId", resultId);
1647
+ assertParamExists('retrieveExecutionMetadata', 'resultId', resultId);
1582
1648
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute/result/{resultId}/metadata`
1583
1649
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
1584
1650
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -1588,7 +1654,7 @@ export async function ActionsApiAxiosParamCreator_RetrieveExecutionMetadata(work
1588
1654
  if (configuration) {
1589
1655
  baseOptions = configuration.baseOptions;
1590
1656
  }
1591
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1657
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1592
1658
  const localVarHeaderParameter = {};
1593
1659
  const localVarQueryParameter = {};
1594
1660
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1619,9 +1685,9 @@ export async function ActionsApiAxiosParamCreator_RetrieveExecutionMetadata(work
1619
1685
  */
1620
1686
  export async function ActionsApiAxiosParamCreator_RetrieveResult(workspaceId, resultId, offset, limit, excludedTotalDimensions, xGDCCANCELTOKEN, options = {}, configuration) {
1621
1687
  // verify required parameter 'workspaceId' is not null or undefined
1622
- assertParamExists("retrieveResult", "workspaceId", workspaceId);
1688
+ assertParamExists('retrieveResult', 'workspaceId', workspaceId);
1623
1689
  // verify required parameter 'resultId' is not null or undefined
1624
- assertParamExists("retrieveResult", "resultId", resultId);
1690
+ assertParamExists('retrieveResult', 'resultId', resultId);
1625
1691
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute/result/{resultId}`
1626
1692
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
1627
1693
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -1631,20 +1697,20 @@ export async function ActionsApiAxiosParamCreator_RetrieveResult(workspaceId, re
1631
1697
  if (configuration) {
1632
1698
  baseOptions = configuration.baseOptions;
1633
1699
  }
1634
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1700
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1635
1701
  const localVarHeaderParameter = {};
1636
1702
  const localVarQueryParameter = {};
1637
1703
  if (offset) {
1638
- localVarQueryParameter["offset"] = offset.join(COLLECTION_FORMATS.csv);
1704
+ localVarQueryParameter['offset'] = offset.join(COLLECTION_FORMATS.csv);
1639
1705
  }
1640
1706
  if (limit) {
1641
- localVarQueryParameter["limit"] = limit.join(COLLECTION_FORMATS.csv);
1707
+ localVarQueryParameter['limit'] = limit.join(COLLECTION_FORMATS.csv);
1642
1708
  }
1643
1709
  if (excludedTotalDimensions) {
1644
- localVarQueryParameter["excludedTotalDimensions"] = excludedTotalDimensions.join(COLLECTION_FORMATS.csv);
1710
+ localVarQueryParameter['excludedTotalDimensions'] = excludedTotalDimensions.join(COLLECTION_FORMATS.csv);
1645
1711
  }
1646
1712
  if (xGDCCANCELTOKEN !== undefined && xGDCCANCELTOKEN !== null) {
1647
- localVarHeaderParameter["X-GDC-CANCEL-TOKEN"] = String(xGDCCANCELTOKEN);
1713
+ localVarHeaderParameter['X-GDC-CANCEL-TOKEN'] = String(xGDCCANCELTOKEN);
1648
1714
  }
1649
1715
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1650
1716
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1669,15 +1735,16 @@ export async function ActionsApiAxiosParamCreator_RetrieveResult(workspaceId, re
1669
1735
  */
1670
1736
  export async function ActionsApiAxiosParamCreator_Tags(workspaceId, options = {}, configuration) {
1671
1737
  // verify required parameter 'workspaceId' is not null or undefined
1672
- assertParamExists("tags", "workspaceId", workspaceId);
1673
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/tags`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1738
+ assertParamExists('tags', 'workspaceId', workspaceId);
1739
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/tags`
1740
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1674
1741
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1675
1742
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1676
1743
  let baseOptions;
1677
1744
  if (configuration) {
1678
1745
  baseOptions = configuration.baseOptions;
1679
1746
  }
1680
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
1747
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
1681
1748
  const localVarHeaderParameter = {};
1682
1749
  const localVarQueryParameter = {};
1683
1750
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1703,15 +1770,16 @@ export async function ActionsApiAxiosParamCreator_Tags(workspaceId, options = {}
1703
1770
  */
1704
1771
  export async function ActionsApiAxiosParamCreator_TriggerQualityIssuesCalculation(workspaceId, options = {}, configuration) {
1705
1772
  // verify required parameter 'workspaceId' is not null or undefined
1706
- assertParamExists("triggerQualityIssuesCalculation", "workspaceId", workspaceId);
1707
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues/triggerCheck`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1773
+ assertParamExists('triggerQualityIssuesCalculation', 'workspaceId', workspaceId);
1774
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues/triggerCheck`
1775
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1708
1776
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1709
1777
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1710
1778
  let baseOptions;
1711
1779
  if (configuration) {
1712
1780
  baseOptions = configuration.baseOptions;
1713
1781
  }
1714
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1782
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1715
1783
  const localVarHeaderParameter = {};
1716
1784
  const localVarQueryParameter = {};
1717
1785
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -1737,7 +1805,7 @@ export async function ActionsApiAxiosParamCreator_TriggerQualityIssuesCalculatio
1737
1805
  */
1738
1806
  export async function ActionsApiAxiosParamCreator_ValidateLLMEndpoint(validateLLMEndpointRequest, options = {}, configuration) {
1739
1807
  // verify required parameter 'validateLLMEndpointRequest' is not null or undefined
1740
- assertParamExists("validateLLMEndpoint", "validateLLMEndpointRequest", validateLLMEndpointRequest);
1808
+ assertParamExists('validateLLMEndpoint', 'validateLLMEndpointRequest', validateLLMEndpointRequest);
1741
1809
  const localVarPath = `/api/v1/actions/ai/llmEndpoint/test`;
1742
1810
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1743
1811
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -1745,13 +1813,15 @@ export async function ActionsApiAxiosParamCreator_ValidateLLMEndpoint(validateLL
1745
1813
  if (configuration) {
1746
1814
  baseOptions = configuration.baseOptions;
1747
1815
  }
1748
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1816
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1749
1817
  const localVarHeaderParameter = {};
1750
1818
  const localVarQueryParameter = {};
1751
- const consumes = ["application/json"];
1819
+ const consumes = [
1820
+ 'application/json'
1821
+ ];
1752
1822
  // use application/json if present, otherwise fallback to the first one
1753
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
1754
- ? "application/json"
1823
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1824
+ ? 'application/json'
1755
1825
  : consumes[0];
1756
1826
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1757
1827
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -1782,21 +1852,24 @@ export async function ActionsApiAxiosParamCreator_ValidateLLMEndpoint(validateLL
1782
1852
  */
1783
1853
  export async function ActionsApiAxiosParamCreator_ValidateLLMEndpointById(llmEndpointId, validateLLMEndpointByIdRequest, options = {}, configuration) {
1784
1854
  // verify required parameter 'llmEndpointId' is not null or undefined
1785
- assertParamExists("validateLLMEndpointById", "llmEndpointId", llmEndpointId);
1786
- const localVarPath = `/api/v1/actions/ai/llmEndpoint/{llmEndpointId}/test`.replace(`{${"llmEndpointId"}}`, encodeURIComponent(String(llmEndpointId)));
1855
+ assertParamExists('validateLLMEndpointById', 'llmEndpointId', llmEndpointId);
1856
+ const localVarPath = `/api/v1/actions/ai/llmEndpoint/{llmEndpointId}/test`
1857
+ .replace(`{${"llmEndpointId"}}`, encodeURIComponent(String(llmEndpointId)));
1787
1858
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
1788
1859
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
1789
1860
  let baseOptions;
1790
1861
  if (configuration) {
1791
1862
  baseOptions = configuration.baseOptions;
1792
1863
  }
1793
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
1864
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
1794
1865
  const localVarHeaderParameter = {};
1795
1866
  const localVarQueryParameter = {};
1796
- const consumes = ["application/json"];
1867
+ const consumes = [
1868
+ 'application/json'
1869
+ ];
1797
1870
  // use application/json if present, otherwise fallback to the first one
1798
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
1799
- ? "application/json"
1871
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
1872
+ ? 'application/json'
1800
1873
  : consumes[0];
1801
1874
  setSearchParams(localVarUrlObj, localVarQueryParameter);
1802
1875
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -2719,23 +2792,26 @@ export class ActionsApi extends BaseAPI {
2719
2792
  */
2720
2793
  export async function ComputationApiAxiosParamCreator_CancelExecutions(workspaceId, afmCancelTokens, options = {}, configuration) {
2721
2794
  // verify required parameter 'workspaceId' is not null or undefined
2722
- assertParamExists("cancelExecutions", "workspaceId", workspaceId);
2795
+ assertParamExists('cancelExecutions', 'workspaceId', workspaceId);
2723
2796
  // verify required parameter 'afmCancelTokens' is not null or undefined
2724
- assertParamExists("cancelExecutions", "afmCancelTokens", afmCancelTokens);
2725
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/cancel`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2797
+ assertParamExists('cancelExecutions', 'afmCancelTokens', afmCancelTokens);
2798
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/cancel`
2799
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2726
2800
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
2727
2801
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
2728
2802
  let baseOptions;
2729
2803
  if (configuration) {
2730
2804
  baseOptions = configuration.baseOptions;
2731
2805
  }
2732
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
2806
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
2733
2807
  const localVarHeaderParameter = {};
2734
2808
  const localVarQueryParameter = {};
2735
- const consumes = ["application/json"];
2809
+ const consumes = [
2810
+ 'application/json'
2811
+ ];
2736
2812
  // use application/json if present, otherwise fallback to the first one
2737
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
2738
- ? "application/json"
2813
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
2814
+ ? 'application/json'
2739
2815
  : consumes[0];
2740
2816
  setSearchParams(localVarUrlObj, localVarQueryParameter);
2741
2817
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -2766,23 +2842,26 @@ export async function ComputationApiAxiosParamCreator_CancelExecutions(workspace
2766
2842
  */
2767
2843
  export async function ComputationApiAxiosParamCreator_ChangeAnalysis(workspaceId, changeAnalysisRequest, options = {}, configuration) {
2768
2844
  // verify required parameter 'workspaceId' is not null or undefined
2769
- assertParamExists("changeAnalysis", "workspaceId", workspaceId);
2845
+ assertParamExists('changeAnalysis', 'workspaceId', workspaceId);
2770
2846
  // verify required parameter 'changeAnalysisRequest' is not null or undefined
2771
- assertParamExists("changeAnalysis", "changeAnalysisRequest", changeAnalysisRequest);
2772
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeChangeAnalysis`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2847
+ assertParamExists('changeAnalysis', 'changeAnalysisRequest', changeAnalysisRequest);
2848
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeChangeAnalysis`
2849
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2773
2850
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
2774
2851
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
2775
2852
  let baseOptions;
2776
2853
  if (configuration) {
2777
2854
  baseOptions = configuration.baseOptions;
2778
2855
  }
2779
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
2856
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
2780
2857
  const localVarHeaderParameter = {};
2781
2858
  const localVarQueryParameter = {};
2782
- const consumes = ["application/json"];
2859
+ const consumes = [
2860
+ 'application/json'
2861
+ ];
2783
2862
  // use application/json if present, otherwise fallback to the first one
2784
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
2785
- ? "application/json"
2863
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
2864
+ ? 'application/json'
2786
2865
  : consumes[0];
2787
2866
  setSearchParams(localVarUrlObj, localVarQueryParameter);
2788
2867
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -2813,9 +2892,9 @@ export async function ComputationApiAxiosParamCreator_ChangeAnalysis(workspaceId
2813
2892
  */
2814
2893
  export async function ComputationApiAxiosParamCreator_ChangeAnalysisResult(workspaceId, resultId, options = {}, configuration) {
2815
2894
  // verify required parameter 'workspaceId' is not null or undefined
2816
- assertParamExists("changeAnalysisResult", "workspaceId", workspaceId);
2895
+ assertParamExists('changeAnalysisResult', 'workspaceId', workspaceId);
2817
2896
  // verify required parameter 'resultId' is not null or undefined
2818
- assertParamExists("changeAnalysisResult", "resultId", resultId);
2897
+ assertParamExists('changeAnalysisResult', 'resultId', resultId);
2819
2898
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeChangeAnalysis/result/{resultId}`
2820
2899
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
2821
2900
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -2825,7 +2904,7 @@ export async function ComputationApiAxiosParamCreator_ChangeAnalysisResult(works
2825
2904
  if (configuration) {
2826
2905
  baseOptions = configuration.baseOptions;
2827
2906
  }
2828
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
2907
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
2829
2908
  const localVarHeaderParameter = {};
2830
2909
  const localVarQueryParameter = {};
2831
2910
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -2855,32 +2934,35 @@ export async function ComputationApiAxiosParamCreator_ChangeAnalysisResult(works
2855
2934
  */
2856
2935
  export async function ComputationApiAxiosParamCreator_ComputeLabelElementsPost(workspaceId, elementsRequest, offset, limit, skipCache, options = {}, configuration) {
2857
2936
  // verify required parameter 'workspaceId' is not null or undefined
2858
- assertParamExists("computeLabelElementsPost", "workspaceId", workspaceId);
2937
+ assertParamExists('computeLabelElementsPost', 'workspaceId', workspaceId);
2859
2938
  // verify required parameter 'elementsRequest' is not null or undefined
2860
- assertParamExists("computeLabelElementsPost", "elementsRequest", elementsRequest);
2861
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/collectLabelElements`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2939
+ assertParamExists('computeLabelElementsPost', 'elementsRequest', elementsRequest);
2940
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/collectLabelElements`
2941
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2862
2942
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
2863
2943
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
2864
2944
  let baseOptions;
2865
2945
  if (configuration) {
2866
2946
  baseOptions = configuration.baseOptions;
2867
2947
  }
2868
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
2948
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
2869
2949
  const localVarHeaderParameter = {};
2870
2950
  const localVarQueryParameter = {};
2871
2951
  if (offset !== undefined) {
2872
- localVarQueryParameter["offset"] = offset;
2952
+ localVarQueryParameter['offset'] = offset;
2873
2953
  }
2874
2954
  if (limit !== undefined) {
2875
- localVarQueryParameter["limit"] = limit;
2955
+ localVarQueryParameter['limit'] = limit;
2876
2956
  }
2877
2957
  if (skipCache !== undefined && skipCache !== null) {
2878
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
2958
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
2879
2959
  }
2880
- const consumes = ["application/json"];
2960
+ const consumes = [
2961
+ 'application/json'
2962
+ ];
2881
2963
  // use application/json if present, otherwise fallback to the first one
2882
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
2883
- ? "application/json"
2964
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
2965
+ ? 'application/json'
2884
2966
  : consumes[0];
2885
2967
  setSearchParams(localVarUrlObj, localVarQueryParameter);
2886
2968
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -2913,29 +2995,32 @@ export async function ComputationApiAxiosParamCreator_ComputeLabelElementsPost(w
2913
2995
  */
2914
2996
  export async function ComputationApiAxiosParamCreator_ComputeReport(workspaceId, afmExecution, skipCache, timestamp, options = {}, configuration) {
2915
2997
  // verify required parameter 'workspaceId' is not null or undefined
2916
- assertParamExists("computeReport", "workspaceId", workspaceId);
2998
+ assertParamExists('computeReport', 'workspaceId', workspaceId);
2917
2999
  // verify required parameter 'afmExecution' is not null or undefined
2918
- assertParamExists("computeReport", "afmExecution", afmExecution);
2919
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3000
+ assertParamExists('computeReport', 'afmExecution', afmExecution);
3001
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute`
3002
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2920
3003
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
2921
3004
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
2922
3005
  let baseOptions;
2923
3006
  if (configuration) {
2924
3007
  baseOptions = configuration.baseOptions;
2925
3008
  }
2926
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3009
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
2927
3010
  const localVarHeaderParameter = {};
2928
3011
  const localVarQueryParameter = {};
2929
3012
  if (skipCache !== undefined && skipCache !== null) {
2930
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
3013
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
2931
3014
  }
2932
3015
  if (timestamp !== undefined && timestamp !== null) {
2933
- localVarHeaderParameter["timestamp"] = String(timestamp);
3016
+ localVarHeaderParameter['timestamp'] = String(timestamp);
2934
3017
  }
2935
- const consumes = ["application/json"];
3018
+ const consumes = [
3019
+ 'application/json'
3020
+ ];
2936
3021
  // use application/json if present, otherwise fallback to the first one
2937
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
2938
- ? "application/json"
3022
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3023
+ ? 'application/json'
2939
3024
  : consumes[0];
2940
3025
  setSearchParams(localVarUrlObj, localVarQueryParameter);
2941
3026
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -2966,23 +3051,26 @@ export async function ComputationApiAxiosParamCreator_ComputeReport(workspaceId,
2966
3051
  */
2967
3052
  export async function ComputationApiAxiosParamCreator_ComputeValidDescendants(workspaceId, afmValidDescendantsQuery, options = {}, configuration) {
2968
3053
  // verify required parameter 'workspaceId' is not null or undefined
2969
- assertParamExists("computeValidDescendants", "workspaceId", workspaceId);
3054
+ assertParamExists('computeValidDescendants', 'workspaceId', workspaceId);
2970
3055
  // verify required parameter 'afmValidDescendantsQuery' is not null or undefined
2971
- assertParamExists("computeValidDescendants", "afmValidDescendantsQuery", afmValidDescendantsQuery);
2972
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidDescendants`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3056
+ assertParamExists('computeValidDescendants', 'afmValidDescendantsQuery', afmValidDescendantsQuery);
3057
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidDescendants`
3058
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
2973
3059
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
2974
3060
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
2975
3061
  let baseOptions;
2976
3062
  if (configuration) {
2977
3063
  baseOptions = configuration.baseOptions;
2978
3064
  }
2979
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3065
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
2980
3066
  const localVarHeaderParameter = {};
2981
3067
  const localVarQueryParameter = {};
2982
- const consumes = ["application/json"];
3068
+ const consumes = [
3069
+ 'application/json'
3070
+ ];
2983
3071
  // use application/json if present, otherwise fallback to the first one
2984
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
2985
- ? "application/json"
3072
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3073
+ ? 'application/json'
2986
3074
  : consumes[0];
2987
3075
  setSearchParams(localVarUrlObj, localVarQueryParameter);
2988
3076
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3013,23 +3101,26 @@ export async function ComputationApiAxiosParamCreator_ComputeValidDescendants(wo
3013
3101
  */
3014
3102
  export async function ComputationApiAxiosParamCreator_ComputeValidObjects(workspaceId, afmValidObjectsQuery, options = {}, configuration) {
3015
3103
  // verify required parameter 'workspaceId' is not null or undefined
3016
- assertParamExists("computeValidObjects", "workspaceId", workspaceId);
3104
+ assertParamExists('computeValidObjects', 'workspaceId', workspaceId);
3017
3105
  // verify required parameter 'afmValidObjectsQuery' is not null or undefined
3018
- assertParamExists("computeValidObjects", "afmValidObjectsQuery", afmValidObjectsQuery);
3019
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidObjects`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3106
+ assertParamExists('computeValidObjects', 'afmValidObjectsQuery', afmValidObjectsQuery);
3107
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/computeValidObjects`
3108
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3020
3109
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3021
3110
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3022
3111
  let baseOptions;
3023
3112
  if (configuration) {
3024
3113
  baseOptions = configuration.baseOptions;
3025
3114
  }
3026
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3115
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3027
3116
  const localVarHeaderParameter = {};
3028
3117
  const localVarQueryParameter = {};
3029
- const consumes = ["application/json"];
3118
+ const consumes = [
3119
+ 'application/json'
3120
+ ];
3030
3121
  // use application/json if present, otherwise fallback to the first one
3031
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3032
- ? "application/json"
3122
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3123
+ ? 'application/json'
3033
3124
  : consumes[0];
3034
3125
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3035
3126
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3061,26 +3152,29 @@ export async function ComputationApiAxiosParamCreator_ComputeValidObjects(worksp
3061
3152
  */
3062
3153
  export async function ComputationApiAxiosParamCreator_ExplainAFM(workspaceId, afmExecution, explainType, options = {}, configuration) {
3063
3154
  // verify required parameter 'workspaceId' is not null or undefined
3064
- assertParamExists("explainAFM", "workspaceId", workspaceId);
3155
+ assertParamExists('explainAFM', 'workspaceId', workspaceId);
3065
3156
  // verify required parameter 'afmExecution' is not null or undefined
3066
- assertParamExists("explainAFM", "afmExecution", afmExecution);
3067
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/explain`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3157
+ assertParamExists('explainAFM', 'afmExecution', afmExecution);
3158
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/explain`
3159
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3068
3160
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3069
3161
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3070
3162
  let baseOptions;
3071
3163
  if (configuration) {
3072
3164
  baseOptions = configuration.baseOptions;
3073
3165
  }
3074
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3166
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3075
3167
  const localVarHeaderParameter = {};
3076
3168
  const localVarQueryParameter = {};
3077
3169
  if (explainType !== undefined) {
3078
- localVarQueryParameter["explainType"] = explainType;
3170
+ localVarQueryParameter['explainType'] = explainType;
3079
3171
  }
3080
- const consumes = ["application/json"];
3172
+ const consumes = [
3173
+ 'application/json'
3174
+ ];
3081
3175
  // use application/json if present, otherwise fallback to the first one
3082
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3083
- ? "application/json"
3176
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3177
+ ? 'application/json'
3084
3178
  : consumes[0];
3085
3179
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3086
3180
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3112,26 +3206,29 @@ export async function ComputationApiAxiosParamCreator_ExplainAFM(workspaceId, af
3112
3206
  */
3113
3207
  export async function ComputationApiAxiosParamCreator_KeyDriverAnalysis(workspaceId, keyDriversRequest, skipCache, options = {}, configuration) {
3114
3208
  // verify required parameter 'workspaceId' is not null or undefined
3115
- assertParamExists("keyDriverAnalysis", "workspaceId", workspaceId);
3209
+ assertParamExists('keyDriverAnalysis', 'workspaceId', workspaceId);
3116
3210
  // verify required parameter 'keyDriversRequest' is not null or undefined
3117
- assertParamExists("keyDriverAnalysis", "keyDriversRequest", keyDriversRequest);
3118
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeKeyDrivers`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3211
+ assertParamExists('keyDriverAnalysis', 'keyDriversRequest', keyDriversRequest);
3212
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeKeyDrivers`
3213
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3119
3214
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3120
3215
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3121
3216
  let baseOptions;
3122
3217
  if (configuration) {
3123
3218
  baseOptions = configuration.baseOptions;
3124
3219
  }
3125
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3220
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3126
3221
  const localVarHeaderParameter = {};
3127
3222
  const localVarQueryParameter = {};
3128
3223
  if (skipCache !== undefined && skipCache !== null) {
3129
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
3224
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
3130
3225
  }
3131
- const consumes = ["application/json"];
3226
+ const consumes = [
3227
+ 'application/json'
3228
+ ];
3132
3229
  // use application/json if present, otherwise fallback to the first one
3133
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3134
- ? "application/json"
3230
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3231
+ ? 'application/json'
3135
3232
  : consumes[0];
3136
3233
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3137
3234
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3164,9 +3261,9 @@ export async function ComputationApiAxiosParamCreator_KeyDriverAnalysis(workspac
3164
3261
  */
3165
3262
  export async function ComputationApiAxiosParamCreator_KeyDriverAnalysisResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
3166
3263
  // verify required parameter 'workspaceId' is not null or undefined
3167
- assertParamExists("keyDriverAnalysisResult", "workspaceId", workspaceId);
3264
+ assertParamExists('keyDriverAnalysisResult', 'workspaceId', workspaceId);
3168
3265
  // verify required parameter 'resultId' is not null or undefined
3169
- assertParamExists("keyDriverAnalysisResult", "resultId", resultId);
3266
+ assertParamExists('keyDriverAnalysisResult', 'resultId', resultId);
3170
3267
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/computeKeyDrivers/result/{resultId}`
3171
3268
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
3172
3269
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -3176,14 +3273,14 @@ export async function ComputationApiAxiosParamCreator_KeyDriverAnalysisResult(wo
3176
3273
  if (configuration) {
3177
3274
  baseOptions = configuration.baseOptions;
3178
3275
  }
3179
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
3276
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
3180
3277
  const localVarHeaderParameter = {};
3181
3278
  const localVarQueryParameter = {};
3182
3279
  if (offset !== undefined) {
3183
- localVarQueryParameter["offset"] = offset;
3280
+ localVarQueryParameter['offset'] = offset;
3184
3281
  }
3185
3282
  if (limit !== undefined) {
3186
- localVarQueryParameter["limit"] = limit;
3283
+ localVarQueryParameter['limit'] = limit;
3187
3284
  }
3188
3285
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3189
3286
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3210,26 +3307,29 @@ export async function ComputationApiAxiosParamCreator_KeyDriverAnalysisResult(wo
3210
3307
  */
3211
3308
  export async function ComputationApiAxiosParamCreator_OutlierDetection(workspaceId, outlierDetectionRequest, skipCache, options = {}, configuration) {
3212
3309
  // verify required parameter 'workspaceId' is not null or undefined
3213
- assertParamExists("outlierDetection", "workspaceId", workspaceId);
3310
+ assertParamExists('outlierDetection', 'workspaceId', workspaceId);
3214
3311
  // verify required parameter 'outlierDetectionRequest' is not null or undefined
3215
- assertParamExists("outlierDetection", "outlierDetectionRequest", outlierDetectionRequest);
3216
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/detectOutliers`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3312
+ assertParamExists('outlierDetection', 'outlierDetectionRequest', outlierDetectionRequest);
3313
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/detectOutliers`
3314
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3217
3315
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3218
3316
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3219
3317
  let baseOptions;
3220
3318
  if (configuration) {
3221
3319
  baseOptions = configuration.baseOptions;
3222
3320
  }
3223
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3321
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3224
3322
  const localVarHeaderParameter = {};
3225
3323
  const localVarQueryParameter = {};
3226
3324
  if (skipCache !== undefined && skipCache !== null) {
3227
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
3325
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
3228
3326
  }
3229
- const consumes = ["application/json"];
3327
+ const consumes = [
3328
+ 'application/json'
3329
+ ];
3230
3330
  // use application/json if present, otherwise fallback to the first one
3231
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3232
- ? "application/json"
3331
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3332
+ ? 'application/json'
3233
3333
  : consumes[0];
3234
3334
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3235
3335
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3262,9 +3362,9 @@ export async function ComputationApiAxiosParamCreator_OutlierDetection(workspace
3262
3362
  */
3263
3363
  export async function ComputationApiAxiosParamCreator_OutlierDetectionResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
3264
3364
  // verify required parameter 'workspaceId' is not null or undefined
3265
- assertParamExists("outlierDetectionResult", "workspaceId", workspaceId);
3365
+ assertParamExists('outlierDetectionResult', 'workspaceId', workspaceId);
3266
3366
  // verify required parameter 'resultId' is not null or undefined
3267
- assertParamExists("outlierDetectionResult", "resultId", resultId);
3367
+ assertParamExists('outlierDetectionResult', 'resultId', resultId);
3268
3368
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/detectOutliers/result/{resultId}`
3269
3369
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
3270
3370
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -3274,14 +3374,14 @@ export async function ComputationApiAxiosParamCreator_OutlierDetectionResult(wor
3274
3374
  if (configuration) {
3275
3375
  baseOptions = configuration.baseOptions;
3276
3376
  }
3277
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
3377
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
3278
3378
  const localVarHeaderParameter = {};
3279
3379
  const localVarQueryParameter = {};
3280
3380
  if (offset !== undefined) {
3281
- localVarQueryParameter["offset"] = offset;
3381
+ localVarQueryParameter['offset'] = offset;
3282
3382
  }
3283
3383
  if (limit !== undefined) {
3284
- localVarQueryParameter["limit"] = limit;
3384
+ localVarQueryParameter['limit'] = limit;
3285
3385
  }
3286
3386
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3287
3387
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3307,9 +3407,9 @@ export async function ComputationApiAxiosParamCreator_OutlierDetectionResult(wor
3307
3407
  */
3308
3408
  export async function ComputationApiAxiosParamCreator_RetrieveExecutionMetadata(workspaceId, resultId, options = {}, configuration) {
3309
3409
  // verify required parameter 'workspaceId' is not null or undefined
3310
- assertParamExists("retrieveExecutionMetadata", "workspaceId", workspaceId);
3410
+ assertParamExists('retrieveExecutionMetadata', 'workspaceId', workspaceId);
3311
3411
  // verify required parameter 'resultId' is not null or undefined
3312
- assertParamExists("retrieveExecutionMetadata", "resultId", resultId);
3412
+ assertParamExists('retrieveExecutionMetadata', 'resultId', resultId);
3313
3413
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute/result/{resultId}/metadata`
3314
3414
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
3315
3415
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -3319,7 +3419,7 @@ export async function ComputationApiAxiosParamCreator_RetrieveExecutionMetadata(
3319
3419
  if (configuration) {
3320
3420
  baseOptions = configuration.baseOptions;
3321
3421
  }
3322
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
3422
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
3323
3423
  const localVarHeaderParameter = {};
3324
3424
  const localVarQueryParameter = {};
3325
3425
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -3350,9 +3450,9 @@ export async function ComputationApiAxiosParamCreator_RetrieveExecutionMetadata(
3350
3450
  */
3351
3451
  export async function ComputationApiAxiosParamCreator_RetrieveResult(workspaceId, resultId, offset, limit, excludedTotalDimensions, xGDCCANCELTOKEN, options = {}, configuration) {
3352
3452
  // verify required parameter 'workspaceId' is not null or undefined
3353
- assertParamExists("retrieveResult", "workspaceId", workspaceId);
3453
+ assertParamExists('retrieveResult', 'workspaceId', workspaceId);
3354
3454
  // verify required parameter 'resultId' is not null or undefined
3355
- assertParamExists("retrieveResult", "resultId", resultId);
3455
+ assertParamExists('retrieveResult', 'resultId', resultId);
3356
3456
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/afm/execute/result/{resultId}`
3357
3457
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
3358
3458
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -3362,20 +3462,20 @@ export async function ComputationApiAxiosParamCreator_RetrieveResult(workspaceId
3362
3462
  if (configuration) {
3363
3463
  baseOptions = configuration.baseOptions;
3364
3464
  }
3365
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
3465
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
3366
3466
  const localVarHeaderParameter = {};
3367
3467
  const localVarQueryParameter = {};
3368
3468
  if (offset) {
3369
- localVarQueryParameter["offset"] = offset.join(COLLECTION_FORMATS.csv);
3469
+ localVarQueryParameter['offset'] = offset.join(COLLECTION_FORMATS.csv);
3370
3470
  }
3371
3471
  if (limit) {
3372
- localVarQueryParameter["limit"] = limit.join(COLLECTION_FORMATS.csv);
3472
+ localVarQueryParameter['limit'] = limit.join(COLLECTION_FORMATS.csv);
3373
3473
  }
3374
3474
  if (excludedTotalDimensions) {
3375
- localVarQueryParameter["excludedTotalDimensions"] = excludedTotalDimensions.join(COLLECTION_FORMATS.csv);
3475
+ localVarQueryParameter['excludedTotalDimensions'] = excludedTotalDimensions.join(COLLECTION_FORMATS.csv);
3376
3476
  }
3377
3477
  if (xGDCCANCELTOKEN !== undefined && xGDCCANCELTOKEN !== null) {
3378
- localVarHeaderParameter["X-GDC-CANCEL-TOKEN"] = String(xGDCCANCELTOKEN);
3478
+ localVarHeaderParameter['X-GDC-CANCEL-TOKEN'] = String(xGDCCANCELTOKEN);
3379
3479
  }
3380
3480
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3381
3481
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3773,23 +3873,26 @@ export class ComputationApi extends BaseAPI {
3773
3873
  */
3774
3874
  export async function SmartFunctionsApiAxiosParamCreator_AiChat(workspaceId, chatRequest, options = {}, configuration) {
3775
3875
  // verify required parameter 'workspaceId' is not null or undefined
3776
- assertParamExists("aiChat", "workspaceId", workspaceId);
3876
+ assertParamExists('aiChat', 'workspaceId', workspaceId);
3777
3877
  // verify required parameter 'chatRequest' is not null or undefined
3778
- assertParamExists("aiChat", "chatRequest", chatRequest);
3779
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chat`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3878
+ assertParamExists('aiChat', 'chatRequest', chatRequest);
3879
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chat`
3880
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3780
3881
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3781
3882
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3782
3883
  let baseOptions;
3783
3884
  if (configuration) {
3784
3885
  baseOptions = configuration.baseOptions;
3785
3886
  }
3786
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3887
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3787
3888
  const localVarHeaderParameter = {};
3788
3889
  const localVarQueryParameter = {};
3789
- const consumes = ["application/json"];
3890
+ const consumes = [
3891
+ 'application/json'
3892
+ ];
3790
3893
  // use application/json if present, otherwise fallback to the first one
3791
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3792
- ? "application/json"
3894
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3895
+ ? 'application/json'
3793
3896
  : consumes[0];
3794
3897
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3795
3898
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3820,23 +3923,26 @@ export async function SmartFunctionsApiAxiosParamCreator_AiChat(workspaceId, cha
3820
3923
  */
3821
3924
  export async function SmartFunctionsApiAxiosParamCreator_AiChatHistory(workspaceId, chatHistoryRequest, options = {}, configuration) {
3822
3925
  // verify required parameter 'workspaceId' is not null or undefined
3823
- assertParamExists("aiChatHistory", "workspaceId", workspaceId);
3926
+ assertParamExists('aiChatHistory', 'workspaceId', workspaceId);
3824
3927
  // verify required parameter 'chatHistoryRequest' is not null or undefined
3825
- assertParamExists("aiChatHistory", "chatHistoryRequest", chatHistoryRequest);
3826
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatHistory`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3928
+ assertParamExists('aiChatHistory', 'chatHistoryRequest', chatHistoryRequest);
3929
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatHistory`
3930
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3827
3931
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3828
3932
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3829
3933
  let baseOptions;
3830
3934
  if (configuration) {
3831
3935
  baseOptions = configuration.baseOptions;
3832
3936
  }
3833
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3937
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3834
3938
  const localVarHeaderParameter = {};
3835
3939
  const localVarQueryParameter = {};
3836
- const consumes = ["application/json"];
3940
+ const consumes = [
3941
+ 'application/json'
3942
+ ];
3837
3943
  // use application/json if present, otherwise fallback to the first one
3838
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3839
- ? "application/json"
3944
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3945
+ ? 'application/json'
3840
3946
  : consumes[0];
3841
3947
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3842
3948
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3867,23 +3973,26 @@ export async function SmartFunctionsApiAxiosParamCreator_AiChatHistory(workspace
3867
3973
  */
3868
3974
  export async function SmartFunctionsApiAxiosParamCreator_AiChatStream(workspaceId, chatRequest, options = {}, configuration) {
3869
3975
  // verify required parameter 'workspaceId' is not null or undefined
3870
- assertParamExists("aiChatStream", "workspaceId", workspaceId);
3976
+ assertParamExists('aiChatStream', 'workspaceId', workspaceId);
3871
3977
  // verify required parameter 'chatRequest' is not null or undefined
3872
- assertParamExists("aiChatStream", "chatRequest", chatRequest);
3873
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatStream`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3978
+ assertParamExists('aiChatStream', 'chatRequest', chatRequest);
3979
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatStream`
3980
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3874
3981
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3875
3982
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3876
3983
  let baseOptions;
3877
3984
  if (configuration) {
3878
3985
  baseOptions = configuration.baseOptions;
3879
3986
  }
3880
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
3987
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3881
3988
  const localVarHeaderParameter = {};
3882
3989
  const localVarQueryParameter = {};
3883
- const consumes = ["application/json"];
3990
+ const consumes = [
3991
+ 'application/json'
3992
+ ];
3884
3993
  // use application/json if present, otherwise fallback to the first one
3885
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3886
- ? "application/json"
3994
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
3995
+ ? 'application/json'
3887
3996
  : consumes[0];
3888
3997
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3889
3998
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3913,15 +4022,16 @@ export async function SmartFunctionsApiAxiosParamCreator_AiChatStream(workspaceI
3913
4022
  */
3914
4023
  export async function SmartFunctionsApiAxiosParamCreator_AiChatUsage(workspaceId, options = {}, configuration) {
3915
4024
  // verify required parameter 'workspaceId' is not null or undefined
3916
- assertParamExists("aiChatUsage", "workspaceId", workspaceId);
3917
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatUsage`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4025
+ assertParamExists('aiChatUsage', 'workspaceId', workspaceId);
4026
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/chatUsage`
4027
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3918
4028
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3919
4029
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3920
4030
  let baseOptions;
3921
4031
  if (configuration) {
3922
4032
  baseOptions = configuration.baseOptions;
3923
4033
  }
3924
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4034
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
3925
4035
  const localVarHeaderParameter = {};
3926
4036
  const localVarQueryParameter = {};
3927
4037
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -3948,23 +4058,26 @@ export async function SmartFunctionsApiAxiosParamCreator_AiChatUsage(workspaceId
3948
4058
  */
3949
4059
  export async function SmartFunctionsApiAxiosParamCreator_AiSearch(workspaceId, searchRequest, options = {}, configuration) {
3950
4060
  // verify required parameter 'workspaceId' is not null or undefined
3951
- assertParamExists("aiSearch", "workspaceId", workspaceId);
4061
+ assertParamExists('aiSearch', 'workspaceId', workspaceId);
3952
4062
  // verify required parameter 'searchRequest' is not null or undefined
3953
- assertParamExists("aiSearch", "searchRequest", searchRequest);
3954
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/search`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4063
+ assertParamExists('aiSearch', 'searchRequest', searchRequest);
4064
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/search`
4065
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
3955
4066
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
3956
4067
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
3957
4068
  let baseOptions;
3958
4069
  if (configuration) {
3959
4070
  baseOptions = configuration.baseOptions;
3960
4071
  }
3961
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
4072
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
3962
4073
  const localVarHeaderParameter = {};
3963
4074
  const localVarQueryParameter = {};
3964
- const consumes = ["application/json"];
4075
+ const consumes = [
4076
+ 'application/json'
4077
+ ];
3965
4078
  // use application/json if present, otherwise fallback to the first one
3966
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
3967
- ? "application/json"
4079
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
4080
+ ? 'application/json'
3968
4081
  : consumes[0];
3969
4082
  setSearchParams(localVarUrlObj, localVarQueryParameter);
3970
4083
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -3997,11 +4110,11 @@ export async function SmartFunctionsApiAxiosParamCreator_AiSearch(workspaceId, s
3997
4110
  */
3998
4111
  export async function SmartFunctionsApiAxiosParamCreator_AnomalyDetection(workspaceId, resultId, anomalyDetectionRequest, skipCache, options = {}, configuration) {
3999
4112
  // verify required parameter 'workspaceId' is not null or undefined
4000
- assertParamExists("anomalyDetection", "workspaceId", workspaceId);
4113
+ assertParamExists('anomalyDetection', 'workspaceId', workspaceId);
4001
4114
  // verify required parameter 'resultId' is not null or undefined
4002
- assertParamExists("anomalyDetection", "resultId", resultId);
4115
+ assertParamExists('anomalyDetection', 'resultId', resultId);
4003
4116
  // verify required parameter 'anomalyDetectionRequest' is not null or undefined
4004
- assertParamExists("anomalyDetection", "anomalyDetectionRequest", anomalyDetectionRequest);
4117
+ assertParamExists('anomalyDetection', 'anomalyDetectionRequest', anomalyDetectionRequest);
4005
4118
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/anomalyDetection/{resultId}`
4006
4119
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
4007
4120
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -4011,16 +4124,18 @@ export async function SmartFunctionsApiAxiosParamCreator_AnomalyDetection(worksp
4011
4124
  if (configuration) {
4012
4125
  baseOptions = configuration.baseOptions;
4013
4126
  }
4014
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
4127
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
4015
4128
  const localVarHeaderParameter = {};
4016
4129
  const localVarQueryParameter = {};
4017
4130
  if (skipCache !== undefined && skipCache !== null) {
4018
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
4131
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
4019
4132
  }
4020
- const consumes = ["application/json"];
4133
+ const consumes = [
4134
+ 'application/json'
4135
+ ];
4021
4136
  // use application/json if present, otherwise fallback to the first one
4022
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
4023
- ? "application/json"
4137
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
4138
+ ? 'application/json'
4024
4139
  : consumes[0];
4025
4140
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4026
4141
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -4053,9 +4168,9 @@ export async function SmartFunctionsApiAxiosParamCreator_AnomalyDetection(worksp
4053
4168
  */
4054
4169
  export async function SmartFunctionsApiAxiosParamCreator_AnomalyDetectionResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
4055
4170
  // verify required parameter 'workspaceId' is not null or undefined
4056
- assertParamExists("anomalyDetectionResult", "workspaceId", workspaceId);
4171
+ assertParamExists('anomalyDetectionResult', 'workspaceId', workspaceId);
4057
4172
  // verify required parameter 'resultId' is not null or undefined
4058
- assertParamExists("anomalyDetectionResult", "resultId", resultId);
4173
+ assertParamExists('anomalyDetectionResult', 'resultId', resultId);
4059
4174
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/anomalyDetection/result/{resultId}`
4060
4175
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
4061
4176
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -4065,14 +4180,14 @@ export async function SmartFunctionsApiAxiosParamCreator_AnomalyDetectionResult(
4065
4180
  if (configuration) {
4066
4181
  baseOptions = configuration.baseOptions;
4067
4182
  }
4068
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4183
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4069
4184
  const localVarHeaderParameter = {};
4070
4185
  const localVarQueryParameter = {};
4071
4186
  if (offset !== undefined) {
4072
- localVarQueryParameter["offset"] = offset;
4187
+ localVarQueryParameter['offset'] = offset;
4073
4188
  }
4074
4189
  if (limit !== undefined) {
4075
- localVarQueryParameter["limit"] = limit;
4190
+ localVarQueryParameter['limit'] = limit;
4076
4191
  }
4077
4192
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4078
4193
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -4100,11 +4215,11 @@ export async function SmartFunctionsApiAxiosParamCreator_AnomalyDetectionResult(
4100
4215
  */
4101
4216
  export async function SmartFunctionsApiAxiosParamCreator_Clustering(workspaceId, resultId, clusteringRequest, skipCache, options = {}, configuration) {
4102
4217
  // verify required parameter 'workspaceId' is not null or undefined
4103
- assertParamExists("clustering", "workspaceId", workspaceId);
4218
+ assertParamExists('clustering', 'workspaceId', workspaceId);
4104
4219
  // verify required parameter 'resultId' is not null or undefined
4105
- assertParamExists("clustering", "resultId", resultId);
4220
+ assertParamExists('clustering', 'resultId', resultId);
4106
4221
  // verify required parameter 'clusteringRequest' is not null or undefined
4107
- assertParamExists("clustering", "clusteringRequest", clusteringRequest);
4222
+ assertParamExists('clustering', 'clusteringRequest', clusteringRequest);
4108
4223
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/clustering/{resultId}`
4109
4224
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
4110
4225
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -4114,16 +4229,18 @@ export async function SmartFunctionsApiAxiosParamCreator_Clustering(workspaceId,
4114
4229
  if (configuration) {
4115
4230
  baseOptions = configuration.baseOptions;
4116
4231
  }
4117
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
4232
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
4118
4233
  const localVarHeaderParameter = {};
4119
4234
  const localVarQueryParameter = {};
4120
4235
  if (skipCache !== undefined && skipCache !== null) {
4121
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
4236
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
4122
4237
  }
4123
- const consumes = ["application/json"];
4238
+ const consumes = [
4239
+ 'application/json'
4240
+ ];
4124
4241
  // use application/json if present, otherwise fallback to the first one
4125
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
4126
- ? "application/json"
4242
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
4243
+ ? 'application/json'
4127
4244
  : consumes[0];
4128
4245
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4129
4246
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -4156,9 +4273,9 @@ export async function SmartFunctionsApiAxiosParamCreator_Clustering(workspaceId,
4156
4273
  */
4157
4274
  export async function SmartFunctionsApiAxiosParamCreator_ClusteringResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
4158
4275
  // verify required parameter 'workspaceId' is not null or undefined
4159
- assertParamExists("clusteringResult", "workspaceId", workspaceId);
4276
+ assertParamExists('clusteringResult', 'workspaceId', workspaceId);
4160
4277
  // verify required parameter 'resultId' is not null or undefined
4161
- assertParamExists("clusteringResult", "resultId", resultId);
4278
+ assertParamExists('clusteringResult', 'resultId', resultId);
4162
4279
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/clustering/result/{resultId}`
4163
4280
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
4164
4281
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -4168,14 +4285,14 @@ export async function SmartFunctionsApiAxiosParamCreator_ClusteringResult(worksp
4168
4285
  if (configuration) {
4169
4286
  baseOptions = configuration.baseOptions;
4170
4287
  }
4171
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4288
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4172
4289
  const localVarHeaderParameter = {};
4173
4290
  const localVarQueryParameter = {};
4174
4291
  if (offset !== undefined) {
4175
- localVarQueryParameter["offset"] = offset;
4292
+ localVarQueryParameter['offset'] = offset;
4176
4293
  }
4177
4294
  if (limit !== undefined) {
4178
- localVarQueryParameter["limit"] = limit;
4295
+ localVarQueryParameter['limit'] = limit;
4179
4296
  }
4180
4297
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4181
4298
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -4200,15 +4317,16 @@ export async function SmartFunctionsApiAxiosParamCreator_ClusteringResult(worksp
4200
4317
  */
4201
4318
  export async function SmartFunctionsApiAxiosParamCreator_CreatedBy(workspaceId, options = {}, configuration) {
4202
4319
  // verify required parameter 'workspaceId' is not null or undefined
4203
- assertParamExists("createdBy", "workspaceId", workspaceId);
4204
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/createdBy`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4320
+ assertParamExists('createdBy', 'workspaceId', workspaceId);
4321
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/createdBy`
4322
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4205
4323
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4206
4324
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
4207
4325
  let baseOptions;
4208
4326
  if (configuration) {
4209
4327
  baseOptions = configuration.baseOptions;
4210
4328
  }
4211
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4329
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4212
4330
  const localVarHeaderParameter = {};
4213
4331
  const localVarQueryParameter = {};
4214
4332
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -4237,11 +4355,11 @@ export async function SmartFunctionsApiAxiosParamCreator_CreatedBy(workspaceId,
4237
4355
  */
4238
4356
  export async function SmartFunctionsApiAxiosParamCreator_Forecast(workspaceId, resultId, forecastRequest, skipCache, options = {}, configuration) {
4239
4357
  // verify required parameter 'workspaceId' is not null or undefined
4240
- assertParamExists("forecast", "workspaceId", workspaceId);
4358
+ assertParamExists('forecast', 'workspaceId', workspaceId);
4241
4359
  // verify required parameter 'resultId' is not null or undefined
4242
- assertParamExists("forecast", "resultId", resultId);
4360
+ assertParamExists('forecast', 'resultId', resultId);
4243
4361
  // verify required parameter 'forecastRequest' is not null or undefined
4244
- assertParamExists("forecast", "forecastRequest", forecastRequest);
4362
+ assertParamExists('forecast', 'forecastRequest', forecastRequest);
4245
4363
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/forecast/{resultId}`
4246
4364
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
4247
4365
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -4251,16 +4369,18 @@ export async function SmartFunctionsApiAxiosParamCreator_Forecast(workspaceId, r
4251
4369
  if (configuration) {
4252
4370
  baseOptions = configuration.baseOptions;
4253
4371
  }
4254
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
4372
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
4255
4373
  const localVarHeaderParameter = {};
4256
4374
  const localVarQueryParameter = {};
4257
4375
  if (skipCache !== undefined && skipCache !== null) {
4258
- localVarHeaderParameter["skip-cache"] = String(JSON.stringify(skipCache));
4376
+ localVarHeaderParameter['skip-cache'] = String(JSON.stringify(skipCache));
4259
4377
  }
4260
- const consumes = ["application/json"];
4378
+ const consumes = [
4379
+ 'application/json'
4380
+ ];
4261
4381
  // use application/json if present, otherwise fallback to the first one
4262
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
4263
- ? "application/json"
4382
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
4383
+ ? 'application/json'
4264
4384
  : consumes[0];
4265
4385
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4266
4386
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -4293,9 +4413,9 @@ export async function SmartFunctionsApiAxiosParamCreator_Forecast(workspaceId, r
4293
4413
  */
4294
4414
  export async function SmartFunctionsApiAxiosParamCreator_ForecastResult(workspaceId, resultId, offset, limit, options = {}, configuration) {
4295
4415
  // verify required parameter 'workspaceId' is not null or undefined
4296
- assertParamExists("forecastResult", "workspaceId", workspaceId);
4416
+ assertParamExists('forecastResult', 'workspaceId', workspaceId);
4297
4417
  // verify required parameter 'resultId' is not null or undefined
4298
- assertParamExists("forecastResult", "resultId", resultId);
4418
+ assertParamExists('forecastResult', 'resultId', resultId);
4299
4419
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/execution/functions/forecast/result/{resultId}`
4300
4420
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
4301
4421
  .replace(`{${"resultId"}}`, encodeURIComponent(String(resultId)));
@@ -4305,14 +4425,14 @@ export async function SmartFunctionsApiAxiosParamCreator_ForecastResult(workspac
4305
4425
  if (configuration) {
4306
4426
  baseOptions = configuration.baseOptions;
4307
4427
  }
4308
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4428
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4309
4429
  const localVarHeaderParameter = {};
4310
4430
  const localVarQueryParameter = {};
4311
4431
  if (offset !== undefined) {
4312
- localVarQueryParameter["offset"] = offset;
4432
+ localVarQueryParameter['offset'] = offset;
4313
4433
  }
4314
4434
  if (limit !== undefined) {
4315
- localVarQueryParameter["limit"] = limit;
4435
+ localVarQueryParameter['limit'] = limit;
4316
4436
  }
4317
4437
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4318
4438
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -4337,15 +4457,16 @@ export async function SmartFunctionsApiAxiosParamCreator_ForecastResult(workspac
4337
4457
  */
4338
4458
  export async function SmartFunctionsApiAxiosParamCreator_GetQualityIssues(workspaceId, options = {}, configuration) {
4339
4459
  // verify required parameter 'workspaceId' is not null or undefined
4340
- assertParamExists("getQualityIssues", "workspaceId", workspaceId);
4341
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4460
+ assertParamExists('getQualityIssues', 'workspaceId', workspaceId);
4461
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues`
4462
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4342
4463
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4343
4464
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
4344
4465
  let baseOptions;
4345
4466
  if (configuration) {
4346
4467
  baseOptions = configuration.baseOptions;
4347
4468
  }
4348
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4469
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4349
4470
  const localVarHeaderParameter = {};
4350
4471
  const localVarQueryParameter = {};
4351
4472
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -4372,9 +4493,9 @@ export async function SmartFunctionsApiAxiosParamCreator_GetQualityIssues(worksp
4372
4493
  */
4373
4494
  export async function SmartFunctionsApiAxiosParamCreator_GetQualityIssuesCalculationStatus(workspaceId, processId, options = {}, configuration) {
4374
4495
  // verify required parameter 'workspaceId' is not null or undefined
4375
- assertParamExists("getQualityIssuesCalculationStatus", "workspaceId", workspaceId);
4496
+ assertParamExists('getQualityIssuesCalculationStatus', 'workspaceId', workspaceId);
4376
4497
  // verify required parameter 'processId' is not null or undefined
4377
- assertParamExists("getQualityIssuesCalculationStatus", "processId", processId);
4498
+ assertParamExists('getQualityIssuesCalculationStatus', 'processId', processId);
4378
4499
  const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues/status/{processId}`
4379
4500
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)))
4380
4501
  .replace(`{${"processId"}}`, encodeURIComponent(String(processId)));
@@ -4384,7 +4505,7 @@ export async function SmartFunctionsApiAxiosParamCreator_GetQualityIssuesCalcula
4384
4505
  if (configuration) {
4385
4506
  baseOptions = configuration.baseOptions;
4386
4507
  }
4387
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4508
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4388
4509
  const localVarHeaderParameter = {};
4389
4510
  const localVarQueryParameter = {};
4390
4511
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -4410,15 +4531,16 @@ export async function SmartFunctionsApiAxiosParamCreator_GetQualityIssuesCalcula
4410
4531
  */
4411
4532
  export async function SmartFunctionsApiAxiosParamCreator_MemoryCreatedByUsers(workspaceId, options = {}, configuration) {
4412
4533
  // verify required parameter 'workspaceId' is not null or undefined
4413
- assertParamExists("memoryCreatedByUsers", "workspaceId", workspaceId);
4414
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/memory/createdBy`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4534
+ assertParamExists('memoryCreatedByUsers', 'workspaceId', workspaceId);
4535
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/memory/createdBy`
4536
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4415
4537
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4416
4538
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
4417
4539
  let baseOptions;
4418
4540
  if (configuration) {
4419
4541
  baseOptions = configuration.baseOptions;
4420
4542
  }
4421
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4543
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4422
4544
  const localVarHeaderParameter = {};
4423
4545
  const localVarQueryParameter = {};
4424
4546
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -4444,15 +4566,16 @@ export async function SmartFunctionsApiAxiosParamCreator_MemoryCreatedByUsers(wo
4444
4566
  */
4445
4567
  export async function SmartFunctionsApiAxiosParamCreator_ResolveLlmEndpoints(workspaceId, options = {}, configuration) {
4446
4568
  // verify required parameter 'workspaceId' is not null or undefined
4447
- assertParamExists("resolveLlmEndpoints", "workspaceId", workspaceId);
4448
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/resolveLlmEndpoints`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4569
+ assertParamExists('resolveLlmEndpoints', 'workspaceId', workspaceId);
4570
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/resolveLlmEndpoints`
4571
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4449
4572
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4450
4573
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
4451
4574
  let baseOptions;
4452
4575
  if (configuration) {
4453
4576
  baseOptions = configuration.baseOptions;
4454
4577
  }
4455
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4578
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4456
4579
  const localVarHeaderParameter = {};
4457
4580
  const localVarQueryParameter = {};
4458
4581
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -4478,15 +4601,16 @@ export async function SmartFunctionsApiAxiosParamCreator_ResolveLlmEndpoints(wor
4478
4601
  */
4479
4602
  export async function SmartFunctionsApiAxiosParamCreator_Tags(workspaceId, options = {}, configuration) {
4480
4603
  // verify required parameter 'workspaceId' is not null or undefined
4481
- assertParamExists("tags", "workspaceId", workspaceId);
4482
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/tags`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4604
+ assertParamExists('tags', 'workspaceId', workspaceId);
4605
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/analyticsCatalog/tags`
4606
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4483
4607
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4484
4608
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
4485
4609
  let baseOptions;
4486
4610
  if (configuration) {
4487
4611
  baseOptions = configuration.baseOptions;
4488
4612
  }
4489
- const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
4613
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
4490
4614
  const localVarHeaderParameter = {};
4491
4615
  const localVarQueryParameter = {};
4492
4616
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -4512,15 +4636,16 @@ export async function SmartFunctionsApiAxiosParamCreator_Tags(workspaceId, optio
4512
4636
  */
4513
4637
  export async function SmartFunctionsApiAxiosParamCreator_TriggerQualityIssuesCalculation(workspaceId, options = {}, configuration) {
4514
4638
  // verify required parameter 'workspaceId' is not null or undefined
4515
- assertParamExists("triggerQualityIssuesCalculation", "workspaceId", workspaceId);
4516
- const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues/triggerCheck`.replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4639
+ assertParamExists('triggerQualityIssuesCalculation', 'workspaceId', workspaceId);
4640
+ const localVarPath = `/api/v1/actions/workspaces/{workspaceId}/ai/issues/triggerCheck`
4641
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
4517
4642
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4518
4643
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
4519
4644
  let baseOptions;
4520
4645
  if (configuration) {
4521
4646
  baseOptions = configuration.baseOptions;
4522
4647
  }
4523
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
4648
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
4524
4649
  const localVarHeaderParameter = {};
4525
4650
  const localVarQueryParameter = {};
4526
4651
  setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -4546,7 +4671,7 @@ export async function SmartFunctionsApiAxiosParamCreator_TriggerQualityIssuesCal
4546
4671
  */
4547
4672
  export async function SmartFunctionsApiAxiosParamCreator_ValidateLLMEndpoint(validateLLMEndpointRequest, options = {}, configuration) {
4548
4673
  // verify required parameter 'validateLLMEndpointRequest' is not null or undefined
4549
- assertParamExists("validateLLMEndpoint", "validateLLMEndpointRequest", validateLLMEndpointRequest);
4674
+ assertParamExists('validateLLMEndpoint', 'validateLLMEndpointRequest', validateLLMEndpointRequest);
4550
4675
  const localVarPath = `/api/v1/actions/ai/llmEndpoint/test`;
4551
4676
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4552
4677
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -4554,13 +4679,15 @@ export async function SmartFunctionsApiAxiosParamCreator_ValidateLLMEndpoint(val
4554
4679
  if (configuration) {
4555
4680
  baseOptions = configuration.baseOptions;
4556
4681
  }
4557
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
4682
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
4558
4683
  const localVarHeaderParameter = {};
4559
4684
  const localVarQueryParameter = {};
4560
- const consumes = ["application/json"];
4685
+ const consumes = [
4686
+ 'application/json'
4687
+ ];
4561
4688
  // use application/json if present, otherwise fallback to the first one
4562
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
4563
- ? "application/json"
4689
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
4690
+ ? 'application/json'
4564
4691
  : consumes[0];
4565
4692
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4566
4693
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};
@@ -4591,21 +4718,24 @@ export async function SmartFunctionsApiAxiosParamCreator_ValidateLLMEndpoint(val
4591
4718
  */
4592
4719
  export async function SmartFunctionsApiAxiosParamCreator_ValidateLLMEndpointById(llmEndpointId, validateLLMEndpointByIdRequest, options = {}, configuration) {
4593
4720
  // verify required parameter 'llmEndpointId' is not null or undefined
4594
- assertParamExists("validateLLMEndpointById", "llmEndpointId", llmEndpointId);
4595
- const localVarPath = `/api/v1/actions/ai/llmEndpoint/{llmEndpointId}/test`.replace(`{${"llmEndpointId"}}`, encodeURIComponent(String(llmEndpointId)));
4721
+ assertParamExists('validateLLMEndpointById', 'llmEndpointId', llmEndpointId);
4722
+ const localVarPath = `/api/v1/actions/ai/llmEndpoint/{llmEndpointId}/test`
4723
+ .replace(`{${"llmEndpointId"}}`, encodeURIComponent(String(llmEndpointId)));
4596
4724
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
4597
4725
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
4598
4726
  let baseOptions;
4599
4727
  if (configuration) {
4600
4728
  baseOptions = configuration.baseOptions;
4601
4729
  }
4602
- const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
4730
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
4603
4731
  const localVarHeaderParameter = {};
4604
4732
  const localVarQueryParameter = {};
4605
- const consumes = ["application/json"];
4733
+ const consumes = [
4734
+ 'application/json'
4735
+ ];
4606
4736
  // use application/json if present, otherwise fallback to the first one
4607
- localVarHeaderParameter["Content-Type"] = consumes.includes("application/json")
4608
- ? "application/json"
4737
+ localVarHeaderParameter['Content-Type'] = consumes.includes('application/json')
4738
+ ? 'application/json'
4609
4739
  : consumes[0];
4610
4740
  setSearchParams(localVarUrlObj, localVarQueryParameter);
4611
4741
  const headersFromBaseOptions = baseOptions?.headers ? baseOptions.headers : {};