Namespaces

Classes

Interfaces

1: <?php
2:
3: declare(strict_types=1);
4:
5: /**
6: * SPDX-License-Identifier: Apache-2.0
7: *
8: * The OpenSearch Contributors require contributions made to
9: * this file be licensed under the Apache-2.0 license or a
10: * compatible open source license.
11: *
12: * Modifications Copyright OpenSearch Contributors. See
13: * GitHub history for details.
14: */
15:
16: namespace OpenSearch\Namespaces;
17:
18: use OpenSearch\Endpoints\Ml\ChunkModel;
19: use OpenSearch\Endpoints\Ml\CreateConnector;
20: use OpenSearch\Endpoints\Ml\CreateController;
21: use OpenSearch\Endpoints\Ml\CreateMemory;
22: use OpenSearch\Endpoints\Ml\CreateMessage;
23: use OpenSearch\Endpoints\Ml\CreateModelMeta;
24: use OpenSearch\Endpoints\Ml\DeleteAgent;
25: use OpenSearch\Endpoints\Ml\DeleteConnector;
26: use OpenSearch\Endpoints\Ml\DeleteController;
27: use OpenSearch\Endpoints\Ml\DeleteMemory;
28: use OpenSearch\Endpoints\Ml\DeleteModel;
29: use OpenSearch\Endpoints\Ml\DeleteModelGroup;
30: use OpenSearch\Endpoints\Ml\DeleteTask;
31: use OpenSearch\Endpoints\Ml\DeployModel;
32: use OpenSearch\Endpoints\Ml\ExecuteAgent;
33: use OpenSearch\Endpoints\Ml\ExecuteAlgorithm;
34: use OpenSearch\Endpoints\Ml\GetAgent;
35: use OpenSearch\Endpoints\Ml\GetAllMemories;
36: use OpenSearch\Endpoints\Ml\GetAllMessages;
37: use OpenSearch\Endpoints\Ml\GetAllTools;
38: use OpenSearch\Endpoints\Ml\GetConnector;
39: use OpenSearch\Endpoints\Ml\GetConnectors;
40: use OpenSearch\Endpoints\Ml\GetController;
41: use OpenSearch\Endpoints\Ml\GetMemory;
42: use OpenSearch\Endpoints\Ml\GetMessage;
43: use OpenSearch\Endpoints\Ml\GetMessageTraces;
44: use OpenSearch\Endpoints\Ml\GetModel;
45: use OpenSearch\Endpoints\Ml\GetModelGroup;
46: use OpenSearch\Endpoints\Ml\GetModelGroups;
47: use OpenSearch\Endpoints\Ml\GetProfile;
48: use OpenSearch\Endpoints\Ml\GetProfileModels;
49: use OpenSearch\Endpoints\Ml\GetProfileTasks;
50: use OpenSearch\Endpoints\Ml\GetStats;
51: use OpenSearch\Endpoints\Ml\GetTask;
52: use OpenSearch\Endpoints\Ml\GetTool;
53: use OpenSearch\Endpoints\Ml\LoadModel;
54: use OpenSearch\Endpoints\Ml\Predict;
55: use OpenSearch\Endpoints\Ml\PredictModel;
56: use OpenSearch\Endpoints\Ml\RegisterAgents;
57: use OpenSearch\Endpoints\Ml\RegisterModel;
58: use OpenSearch\Endpoints\Ml\RegisterModelGroup;
59: use OpenSearch\Endpoints\Ml\RegisterModelMeta;
60: use OpenSearch\Endpoints\Ml\SearchAgents;
61: use OpenSearch\Endpoints\Ml\SearchConnectors;
62: use OpenSearch\Endpoints\Ml\SearchMemory;
63: use OpenSearch\Endpoints\Ml\SearchMessage;
64: use OpenSearch\Endpoints\Ml\SearchModelGroup;
65: use OpenSearch\Endpoints\Ml\SearchModels;
66: use OpenSearch\Endpoints\Ml\SearchTasks;
67: use OpenSearch\Endpoints\Ml\Train;
68: use OpenSearch\Endpoints\Ml\TrainPredict;
69: use OpenSearch\Endpoints\Ml\UndeployModel;
70: use OpenSearch\Endpoints\Ml\UnloadModel;
71: use OpenSearch\Endpoints\Ml\UpdateConnector;
72: use OpenSearch\Endpoints\Ml\UpdateController;
73: use OpenSearch\Endpoints\Ml\UpdateMemory;
74: use OpenSearch\Endpoints\Ml\UpdateMessage;
75: use OpenSearch\Endpoints\Ml\UpdateModel;
76: use OpenSearch\Endpoints\Ml\UpdateModelGroup;
77: use OpenSearch\Endpoints\Ml\UploadChunk;
78: use OpenSearch\Endpoints\Ml\UploadModel;
79:
80: /**
81: * Class MlNamespace
82: *
83: * NOTE: This file is autogenerated using util/GenerateEndpoints.php
84: */
85: class MlNamespace extends AbstractNamespace
86: {
87: /**
88: * Uploads model chunk.
89: *
90: * $params['chunk_number'] = (integer)
91: * $params['model_id'] = (string)
92: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
93: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
94: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
95: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
96: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
97: *
98: * @param array $params Associative array of parameters
99: * @return array
100: */
101: public function chunkModel(array $params = [])
102: {
103: $chunk_number = $this->extractArgument($params, 'chunk_number');
104: $model_id = $this->extractArgument($params, 'model_id');
105: $body = $this->extractArgument($params, 'body');
106:
107: $endpoint = $this->endpointFactory->getEndpoint(ChunkModel::class);
108: $endpoint->setParams($params);
109: $endpoint->setChunkNumber($chunk_number);
110: $endpoint->setModelId($model_id);
111: $endpoint->setBody($body);
112:
113: return $this->performRequest($endpoint);
114: }
115:
116: /**
117: * Creates a controller.
118: *
119: * $params['model_id'] = (string)
120: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
121: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
122: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
123: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
124: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
125: *
126: * @param array $params Associative array of parameters
127: * @return array
128: */
129: public function createController(array $params = [])
130: {
131: $model_id = $this->extractArgument($params, 'model_id');
132: $body = $this->extractArgument($params, 'body');
133:
134: $endpoint = $this->endpointFactory->getEndpoint(CreateController::class);
135: $endpoint->setParams($params);
136: $endpoint->setModelId($model_id);
137: $endpoint->setBody($body);
138:
139: return $this->performRequest($endpoint);
140: }
141:
142: /**
143: * Create a memory.
144: *
145: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
146: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
147: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
148: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
149: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
150: *
151: * @param array $params Associative array of parameters
152: * @return array
153: */
154: public function createMemory(array $params = [])
155: {
156: $body = $this->extractArgument($params, 'body');
157:
158: $endpoint = $this->endpointFactory->getEndpoint(CreateMemory::class);
159: $endpoint->setParams($params);
160: $endpoint->setBody($body);
161:
162: return $this->performRequest($endpoint);
163: }
164:
165: /**
166: * Create a message.
167: *
168: * $params['memory_id'] = (string)
169: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
170: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
171: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
172: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
173: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
174: *
175: * @param array $params Associative array of parameters
176: * @return array
177: */
178: public function createMessage(array $params = [])
179: {
180: $memory_id = $this->extractArgument($params, 'memory_id');
181: $body = $this->extractArgument($params, 'body');
182:
183: $endpoint = $this->endpointFactory->getEndpoint(CreateMessage::class);
184: $endpoint->setParams($params);
185: $endpoint->setMemoryId($memory_id);
186: $endpoint->setBody($body);
187:
188: return $this->performRequest($endpoint);
189: }
190:
191: /**
192: * Registers model metadata.
193: *
194: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
195: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
196: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
197: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
198: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
199: *
200: * @param array $params Associative array of parameters
201: * @return array
202: */
203: public function createModelMeta(array $params = [])
204: {
205: $body = $this->extractArgument($params, 'body');
206:
207: $endpoint = $this->endpointFactory->getEndpoint(CreateModelMeta::class);
208: $endpoint->setParams($params);
209: $endpoint->setBody($body);
210:
211: return $this->performRequest($endpoint);
212: }
213:
214: /**
215: * Delete an agent.
216: *
217: * $params['agent_id'] = (string)
218: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
219: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
220: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
221: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
222: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
223: *
224: * @param array $params Associative array of parameters
225: * @return array
226: */
227: public function deleteAgent(array $params = [])
228: {
229: $agent_id = $this->extractArgument($params, 'agent_id');
230:
231: $endpoint = $this->endpointFactory->getEndpoint(DeleteAgent::class);
232: $endpoint->setParams($params);
233: $endpoint->setAgentId($agent_id);
234:
235: return $this->performRequest($endpoint);
236: }
237:
238: /**
239: * Deletes a controller.
240: *
241: * $params['model_id'] = (string)
242: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
243: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
244: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
245: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
246: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
247: *
248: * @param array $params Associative array of parameters
249: * @return array
250: */
251: public function deleteController(array $params = [])
252: {
253: $model_id = $this->extractArgument($params, 'model_id');
254:
255: $endpoint = $this->endpointFactory->getEndpoint(DeleteController::class);
256: $endpoint->setParams($params);
257: $endpoint->setModelId($model_id);
258:
259: return $this->performRequest($endpoint);
260: }
261:
262: /**
263: * Delete a memory.
264: *
265: * $params['memory_id'] = (string)
266: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
267: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
268: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
269: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
270: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
271: *
272: * @param array $params Associative array of parameters
273: * @return array
274: */
275: public function deleteMemory(array $params = [])
276: {
277: $memory_id = $this->extractArgument($params, 'memory_id');
278:
279: $endpoint = $this->endpointFactory->getEndpoint(DeleteMemory::class);
280: $endpoint->setParams($params);
281: $endpoint->setMemoryId($memory_id);
282:
283: return $this->performRequest($endpoint);
284: }
285:
286: /**
287: * Deletes a model.
288: *
289: * $params['id'] = (string)
290: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
291: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
292: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
293: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
294: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
295: *
296: * @param array $params Associative array of parameters
297: * @return array
298: */
299: public function deleteModel(array $params = [])
300: {
301: $id = $this->extractArgument($params, 'id');
302:
303: $endpoint = $this->endpointFactory->getEndpoint(DeleteModel::class);
304: $endpoint->setParams($params);
305: $endpoint->setId($id);
306:
307: return $this->performRequest($endpoint);
308: }
309:
310: /**
311: * Deletes a model group.
312: *
313: * $params['id'] = (string)
314: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
315: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
316: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
317: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
318: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
319: *
320: * @param array $params Associative array of parameters
321: * @return array
322: */
323: public function deleteModelGroup(array $params = [])
324: {
325: $id = $this->extractArgument($params, 'id');
326:
327: $endpoint = $this->endpointFactory->getEndpoint(DeleteModelGroup::class);
328: $endpoint->setParams($params);
329: $endpoint->setId($id);
330:
331: return $this->performRequest($endpoint);
332: }
333:
334: /**
335: * Deletes a task.
336: *
337: * $params['task_id'] = (string)
338: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
339: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
340: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
341: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
342: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
343: *
344: * @param array $params Associative array of parameters
345: * @return array
346: */
347: public function deleteTask(array $params = [])
348: {
349: $task_id = $this->extractArgument($params, 'task_id');
350:
351: $endpoint = $this->endpointFactory->getEndpoint(DeleteTask::class);
352: $endpoint->setParams($params);
353: $endpoint->setTaskId($task_id);
354:
355: return $this->performRequest($endpoint);
356: }
357:
358: /**
359: * Execute an agent.
360: *
361: * $params['agent_id'] = (string)
362: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
363: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
364: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
365: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
366: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
367: *
368: * @param array $params Associative array of parameters
369: * @return array
370: */
371: public function executeAgent(array $params = [])
372: {
373: $agent_id = $this->extractArgument($params, 'agent_id');
374: $body = $this->extractArgument($params, 'body');
375:
376: $endpoint = $this->endpointFactory->getEndpoint(ExecuteAgent::class);
377: $endpoint->setParams($params);
378: $endpoint->setAgentId($agent_id);
379: $endpoint->setBody($body);
380:
381: return $this->performRequest($endpoint);
382: }
383:
384: /**
385: * Execute an algorithm.
386: *
387: * $params['algorithm_name'] = (string)
388: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
389: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
390: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
391: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
392: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
393: *
394: * @param array $params Associative array of parameters
395: * @return array
396: */
397: public function executeAlgorithm(array $params = [])
398: {
399: $algorithm_name = $this->extractArgument($params, 'algorithm_name');
400: $body = $this->extractArgument($params, 'body');
401:
402: $endpoint = $this->endpointFactory->getEndpoint(ExecuteAlgorithm::class);
403: $endpoint->setParams($params);
404: $endpoint->setAlgorithmName($algorithm_name);
405: $endpoint->setBody($body);
406:
407: return $this->performRequest($endpoint);
408: }
409:
410: /**
411: * Get an agent.
412: *
413: * $params['agent_id'] = (string)
414: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
415: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
416: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
417: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
418: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
419: *
420: * @param array $params Associative array of parameters
421: * @return array
422: */
423: public function getAgent(array $params = [])
424: {
425: $agent_id = $this->extractArgument($params, 'agent_id');
426:
427: $endpoint = $this->endpointFactory->getEndpoint(GetAgent::class);
428: $endpoint->setParams($params);
429: $endpoint->setAgentId($agent_id);
430:
431: return $this->performRequest($endpoint);
432: }
433:
434: /**
435: * Get all memories.
436: *
437: * $params['max_results'] = (integer)
438: * $params['next_token'] = (integer)
439: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
440: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
441: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
442: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
443: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
444: *
445: * @param array $params Associative array of parameters
446: * @return array
447: */
448: public function getAllMemories(array $params = [])
449: {
450: $endpoint = $this->endpointFactory->getEndpoint(GetAllMemories::class);
451: $endpoint->setParams($params);
452:
453: return $this->performRequest($endpoint);
454: }
455:
456: /**
457: * Get all messages in a memory.
458: *
459: * $params['memory_id'] = (string)
460: * $params['max_results'] = (integer)
461: * $params['next_token'] = (integer)
462: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
463: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
464: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
465: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
466: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
467: *
468: * @param array $params Associative array of parameters
469: * @return array
470: */
471: public function getAllMessages(array $params = [])
472: {
473: $memory_id = $this->extractArgument($params, 'memory_id');
474:
475: $endpoint = $this->endpointFactory->getEndpoint(GetAllMessages::class);
476: $endpoint->setParams($params);
477: $endpoint->setMemoryId($memory_id);
478:
479: return $this->performRequest($endpoint);
480: }
481:
482: /**
483: * Get tools.
484: *
485: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
486: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
487: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
488: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
489: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
490: *
491: * @param array $params Associative array of parameters
492: * @return array
493: */
494: public function getAllTools(array $params = [])
495: {
496: $endpoint = $this->endpointFactory->getEndpoint(GetAllTools::class);
497: $endpoint->setParams($params);
498:
499: return $this->performRequest($endpoint);
500: }
501:
502: /**
503: * Retrieves a controller.
504: *
505: * $params['model_id'] = (string)
506: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
507: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
508: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
509: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
510: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
511: *
512: * @param array $params Associative array of parameters
513: * @return array
514: */
515: public function getController(array $params = [])
516: {
517: $model_id = $this->extractArgument($params, 'model_id');
518:
519: $endpoint = $this->endpointFactory->getEndpoint(GetController::class);
520: $endpoint->setParams($params);
521: $endpoint->setModelId($model_id);
522:
523: return $this->performRequest($endpoint);
524: }
525:
526: /**
527: * Get a memory.
528: *
529: * $params['memory_id'] = (string)
530: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
531: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
532: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
533: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
534: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
535: *
536: * @param array $params Associative array of parameters
537: * @return array
538: */
539: public function getMemory(array $params = [])
540: {
541: $memory_id = $this->extractArgument($params, 'memory_id');
542:
543: $endpoint = $this->endpointFactory->getEndpoint(GetMemory::class);
544: $endpoint->setParams($params);
545: $endpoint->setMemoryId($memory_id);
546:
547: return $this->performRequest($endpoint);
548: }
549:
550: /**
551: * Get a message.
552: *
553: * $params['message_id'] = (string)
554: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
555: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
556: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
557: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
558: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
559: *
560: * @param array $params Associative array of parameters
561: * @return array
562: */
563: public function getMessage(array $params = [])
564: {
565: $message_id = $this->extractArgument($params, 'message_id');
566:
567: $endpoint = $this->endpointFactory->getEndpoint(GetMessage::class);
568: $endpoint->setParams($params);
569: $endpoint->setMessageId($message_id);
570:
571: return $this->performRequest($endpoint);
572: }
573:
574: /**
575: * Get a message traces.
576: *
577: * $params['message_id'] = (string)
578: * $params['max_results'] = (integer)
579: * $params['next_token'] = (integer)
580: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
581: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
582: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
583: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
584: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
585: *
586: * @param array $params Associative array of parameters
587: * @return array
588: */
589: public function getMessageTraces(array $params = [])
590: {
591: $message_id = $this->extractArgument($params, 'message_id');
592:
593: $endpoint = $this->endpointFactory->getEndpoint(GetMessageTraces::class);
594: $endpoint->setParams($params);
595: $endpoint->setMessageId($message_id);
596:
597: return $this->performRequest($endpoint);
598: }
599:
600: /**
601: * Retrieves a model group.
602: *
603: * $params['model_group_id'] = (string)
604: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
605: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
606: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
607: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
608: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
609: *
610: * @param array $params Associative array of parameters
611: * @return array
612: */
613: public function getModelGroup(array $params = [])
614: {
615: $model_group_id = $this->extractArgument($params, 'model_group_id');
616:
617: $endpoint = $this->endpointFactory->getEndpoint(GetModelGroup::class);
618: $endpoint->setParams($params);
619: $endpoint->setModelGroupId($model_group_id);
620:
621: return $this->performRequest($endpoint);
622: }
623:
624: /**
625: * Get a profile.
626: *
627: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
628: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
629: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
630: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
631: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
632: *
633: * @param array $params Associative array of parameters
634: * @return array
635: */
636: public function getProfile(array $params = [])
637: {
638: $body = $this->extractArgument($params, 'body');
639:
640: $endpoint = $this->endpointFactory->getEndpoint(GetProfile::class);
641: $endpoint->setParams($params);
642: $endpoint->setBody($body);
643:
644: return $this->performRequest($endpoint);
645: }
646:
647: /**
648: * Get a profile models.
649: *
650: * $params['model_id'] = (string)
651: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
652: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
653: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
654: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
655: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
656: *
657: * @param array $params Associative array of parameters
658: * @return array
659: */
660: public function getProfileModels(array $params = [])
661: {
662: $model_id = $this->extractArgument($params, 'model_id');
663: $body = $this->extractArgument($params, 'body');
664:
665: $endpoint = $this->endpointFactory->getEndpoint(GetProfileModels::class);
666: $endpoint->setParams($params);
667: $endpoint->setModelId($model_id);
668: $endpoint->setBody($body);
669:
670: return $this->performRequest($endpoint);
671: }
672:
673: /**
674: * Get a profile tasks.
675: *
676: * $params['task_id'] = (string)
677: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
678: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
679: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
680: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
681: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
682: *
683: * @param array $params Associative array of parameters
684: * @return array
685: */
686: public function getProfileTasks(array $params = [])
687: {
688: $task_id = $this->extractArgument($params, 'task_id');
689: $body = $this->extractArgument($params, 'body');
690:
691: $endpoint = $this->endpointFactory->getEndpoint(GetProfileTasks::class);
692: $endpoint->setParams($params);
693: $endpoint->setTaskId($task_id);
694: $endpoint->setBody($body);
695:
696: return $this->performRequest($endpoint);
697: }
698:
699: /**
700: * Get stats.
701: *
702: * $params['node_id'] = (string)
703: * $params['stat'] = (array)
704: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
705: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
706: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
707: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
708: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
709: *
710: * @param array $params Associative array of parameters
711: * @return array
712: */
713: public function getStats(array $params = [])
714: {
715: $node_id = $this->extractArgument($params, 'node_id');
716: $stat = $this->extractArgument($params, 'stat');
717:
718: $endpoint = $this->endpointFactory->getEndpoint(GetStats::class);
719: $endpoint->setParams($params);
720: $endpoint->setNodeId($node_id);
721: $endpoint->setStat($stat);
722:
723: return $this->performRequest($endpoint);
724: }
725:
726: /**
727: * Retrieves a task.
728: *
729: * $params['id'] = (string)
730: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
731: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
732: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
733: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
734: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
735: *
736: * @param array $params Associative array of parameters
737: * @return array
738: */
739: public function getTask(array $params = [])
740: {
741: $id = $this->extractArgument($params, 'id');
742:
743: $endpoint = $this->endpointFactory->getEndpoint(GetTask::class);
744: $endpoint->setParams($params);
745: $endpoint->setId($id);
746:
747: return $this->performRequest($endpoint);
748: }
749:
750: /**
751: * Get tools.
752: *
753: * $params['tool_name'] = (string)
754: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
755: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
756: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
757: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
758: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
759: *
760: * @param array $params Associative array of parameters
761: * @return array
762: */
763: public function getTool(array $params = [])
764: {
765: $tool_name = $this->extractArgument($params, 'tool_name');
766:
767: $endpoint = $this->endpointFactory->getEndpoint(GetTool::class);
768: $endpoint->setParams($params);
769: $endpoint->setToolName($tool_name);
770:
771: return $this->performRequest($endpoint);
772: }
773:
774: /**
775: * Deploys a model.
776: *
777: * $params['model_id'] = (string)
778: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
779: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
780: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
781: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
782: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
783: *
784: * @param array $params Associative array of parameters
785: * @return array
786: */
787: public function loadModel(array $params = [])
788: {
789: $model_id = $this->extractArgument($params, 'model_id');
790:
791: $endpoint = $this->endpointFactory->getEndpoint(LoadModel::class);
792: $endpoint->setParams($params);
793: $endpoint->setModelId($model_id);
794:
795: return $this->performRequest($endpoint);
796: }
797:
798: /**
799: * Predicts a model.
800: *
801: * $params['model_id'] = (string)
802: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
803: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
804: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
805: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
806: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
807: *
808: * @param array $params Associative array of parameters
809: * @return array
810: */
811: public function predictModel(array $params = [])
812: {
813: $model_id = $this->extractArgument($params, 'model_id');
814: $body = $this->extractArgument($params, 'body');
815:
816: $endpoint = $this->endpointFactory->getEndpoint(PredictModel::class);
817: $endpoint->setParams($params);
818: $endpoint->setModelId($model_id);
819: $endpoint->setBody($body);
820:
821: return $this->performRequest($endpoint);
822: }
823:
824: /**
825: * Register an agent.
826: *
827: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
828: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
829: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
830: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
831: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
832: *
833: * @param array $params Associative array of parameters
834: * @return array
835: */
836: public function registerAgents(array $params = [])
837: {
838: $body = $this->extractArgument($params, 'body');
839:
840: $endpoint = $this->endpointFactory->getEndpoint(RegisterAgents::class);
841: $endpoint->setParams($params);
842: $endpoint->setBody($body);
843:
844: return $this->performRequest($endpoint);
845: }
846:
847: /**
848: * Registers a model.
849: *
850: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
851: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
852: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
853: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
854: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
855: *
856: * @param array $params Associative array of parameters
857: * @return array
858: */
859: public function registerModel(array $params = [])
860: {
861: $body = $this->extractArgument($params, 'body');
862:
863: $endpoint = $this->endpointFactory->getEndpoint(RegisterModel::class);
864: $endpoint->setParams($params);
865: $endpoint->setBody($body);
866:
867: return $this->performRequest($endpoint);
868: }
869:
870: /**
871: * Registers a model group.
872: *
873: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
874: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
875: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
876: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
877: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
878: *
879: * @param array $params Associative array of parameters
880: * @return array
881: */
882: public function registerModelGroup(array $params = [])
883: {
884: $body = $this->extractArgument($params, 'body');
885:
886: $endpoint = $this->endpointFactory->getEndpoint(RegisterModelGroup::class);
887: $endpoint->setParams($params);
888: $endpoint->setBody($body);
889:
890: return $this->performRequest($endpoint);
891: }
892:
893: /**
894: * Registers model metadata.
895: *
896: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
897: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
898: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
899: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
900: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
901: *
902: * @param array $params Associative array of parameters
903: * @return array
904: */
905: public function registerModelMeta(array $params = [])
906: {
907: $body = $this->extractArgument($params, 'body');
908:
909: $endpoint = $this->endpointFactory->getEndpoint(RegisterModelMeta::class);
910: $endpoint->setParams($params);
911: $endpoint->setBody($body);
912:
913: return $this->performRequest($endpoint);
914: }
915:
916: /**
917: * Search agents.
918: *
919: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
920: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
921: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
922: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
923: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
924: *
925: * @param array $params Associative array of parameters
926: * @return array
927: */
928: public function searchAgents(array $params = [])
929: {
930: $body = $this->extractArgument($params, 'body');
931:
932: $endpoint = $this->endpointFactory->getEndpoint(SearchAgents::class);
933: $endpoint->setParams($params);
934: $endpoint->setBody($body);
935:
936: return $this->performRequest($endpoint);
937: }
938:
939: /**
940: * Searches for standalone connectors.
941: *
942: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
943: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
944: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
945: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
946: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
947: *
948: * @param array $params Associative array of parameters
949: * @return array
950: */
951: public function searchConnectors(array $params = [])
952: {
953: $body = $this->extractArgument($params, 'body');
954:
955: $endpoint = $this->endpointFactory->getEndpoint(SearchConnectors::class);
956: $endpoint->setParams($params);
957: $endpoint->setBody($body);
958:
959: return $this->performRequest($endpoint);
960: }
961:
962: /**
963: * Search memory.
964: *
965: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
966: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
967: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
968: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
969: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
970: *
971: * @param array $params Associative array of parameters
972: * @return array
973: */
974: public function searchMemory(array $params = [])
975: {
976: $body = $this->extractArgument($params, 'body');
977:
978: $endpoint = $this->endpointFactory->getEndpoint(SearchMemory::class);
979: $endpoint->setParams($params);
980: $endpoint->setBody($body);
981:
982: return $this->performRequest($endpoint);
983: }
984:
985: /**
986: * Search messages.
987: *
988: * $params['memory_id'] = (string)
989: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
990: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
991: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
992: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
993: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
994: *
995: * @param array $params Associative array of parameters
996: * @return array
997: */
998: public function searchMessage(array $params = [])
999: {
1000: $memory_id = $this->extractArgument($params, 'memory_id');
1001: $body = $this->extractArgument($params, 'body');
1002:
1003: $endpoint = $this->endpointFactory->getEndpoint(SearchMessage::class);
1004: $endpoint->setParams($params);
1005: $endpoint->setMemoryId($memory_id);
1006: $endpoint->setBody($body);
1007:
1008: return $this->performRequest($endpoint);
1009: }
1010:
1011: /**
1012: * Searches for model groups.
1013: *
1014: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1015: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1016: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1017: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1018: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1019: *
1020: * @param array $params Associative array of parameters
1021: * @return array
1022: */
1023: public function searchModelGroup(array $params = [])
1024: {
1025: $body = $this->extractArgument($params, 'body');
1026:
1027: $endpoint = $this->endpointFactory->getEndpoint(SearchModelGroup::class);
1028: $endpoint->setParams($params);
1029: $endpoint->setBody($body);
1030:
1031: return $this->performRequest($endpoint);
1032: }
1033:
1034: /**
1035: * Searches for models.
1036: *
1037: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1038: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1039: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1040: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1041: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1042: *
1043: * @param array $params Associative array of parameters
1044: * @return array
1045: */
1046: public function searchModels(array $params = [])
1047: {
1048: $body = $this->extractArgument($params, 'body');
1049:
1050: $endpoint = $this->endpointFactory->getEndpoint(SearchModels::class);
1051: $endpoint->setParams($params);
1052: $endpoint->setBody($body);
1053:
1054: return $this->performRequest($endpoint);
1055: }
1056:
1057: /**
1058: * Searches for tasks.
1059: *
1060: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1061: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1062: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1063: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1064: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1065: *
1066: * @param array $params Associative array of parameters
1067: * @return array
1068: */
1069: public function searchTasks(array $params = [])
1070: {
1071: $body = $this->extractArgument($params, 'body');
1072:
1073: $endpoint = $this->endpointFactory->getEndpoint(SearchTasks::class);
1074: $endpoint->setParams($params);
1075: $endpoint->setBody($body);
1076:
1077: return $this->performRequest($endpoint);
1078: }
1079:
1080: /**
1081: * Trains a model synchronously.
1082: *
1083: * $params['algorithm_name'] = (string)
1084: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1085: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1086: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1087: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1088: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1089: *
1090: * @param array $params Associative array of parameters
1091: * @return array
1092: */
1093: public function train(array $params = [])
1094: {
1095: $algorithm_name = $this->extractArgument($params, 'algorithm_name');
1096: $body = $this->extractArgument($params, 'body');
1097:
1098: $endpoint = $this->endpointFactory->getEndpoint(Train::class);
1099: $endpoint->setParams($params);
1100: $endpoint->setAlgorithmName($algorithm_name);
1101: $endpoint->setBody($body);
1102:
1103: return $this->performRequest($endpoint);
1104: }
1105:
1106: /**
1107: * Trains a model and predicts against the same training dataset.
1108: *
1109: * $params['algorithm_name'] = (string)
1110: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1111: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1112: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1113: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1114: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1115: *
1116: * @param array $params Associative array of parameters
1117: * @return array
1118: */
1119: public function trainPredict(array $params = [])
1120: {
1121: $algorithm_name = $this->extractArgument($params, 'algorithm_name');
1122: $body = $this->extractArgument($params, 'body');
1123:
1124: $endpoint = $this->endpointFactory->getEndpoint(TrainPredict::class);
1125: $endpoint->setParams($params);
1126: $endpoint->setAlgorithmName($algorithm_name);
1127: $endpoint->setBody($body);
1128:
1129: return $this->performRequest($endpoint);
1130: }
1131:
1132: /**
1133: * Unloads a model.
1134: *
1135: * $params['model_id'] = (string)
1136: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1137: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1138: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1139: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1140: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1141: *
1142: * @param array $params Associative array of parameters
1143: * @return array
1144: */
1145: public function unloadModel(array $params = [])
1146: {
1147: $model_id = $this->extractArgument($params, 'model_id');
1148: $body = $this->extractArgument($params, 'body');
1149:
1150: $endpoint = $this->endpointFactory->getEndpoint(UnloadModel::class);
1151: $endpoint->setParams($params);
1152: $endpoint->setModelId($model_id);
1153: $endpoint->setBody($body);
1154:
1155: return $this->performRequest($endpoint);
1156: }
1157:
1158: /**
1159: * Updates a standalone connector.
1160: *
1161: * $params['connector_id'] = (string)
1162: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1163: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1164: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1165: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1166: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1167: *
1168: * @param array $params Associative array of parameters
1169: * @return array
1170: */
1171: public function updateConnector(array $params = [])
1172: {
1173: $connector_id = $this->extractArgument($params, 'connector_id');
1174: $body = $this->extractArgument($params, 'body');
1175:
1176: $endpoint = $this->endpointFactory->getEndpoint(UpdateConnector::class);
1177: $endpoint->setParams($params);
1178: $endpoint->setConnectorId($connector_id);
1179: $endpoint->setBody($body);
1180:
1181: return $this->performRequest($endpoint);
1182: }
1183:
1184: /**
1185: * Updates a controller.
1186: *
1187: * $params['model_id'] = (string)
1188: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1189: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1190: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1191: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1192: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1193: *
1194: * @param array $params Associative array of parameters
1195: * @return array
1196: */
1197: public function updateController(array $params = [])
1198: {
1199: $model_id = $this->extractArgument($params, 'model_id');
1200: $body = $this->extractArgument($params, 'body');
1201:
1202: $endpoint = $this->endpointFactory->getEndpoint(UpdateController::class);
1203: $endpoint->setParams($params);
1204: $endpoint->setModelId($model_id);
1205: $endpoint->setBody($body);
1206:
1207: return $this->performRequest($endpoint);
1208: }
1209:
1210: /**
1211: * Update a memory.
1212: *
1213: * $params['memory_id'] = (string)
1214: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1215: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1216: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1217: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1218: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1219: *
1220: * @param array $params Associative array of parameters
1221: * @return array
1222: */
1223: public function updateMemory(array $params = [])
1224: {
1225: $memory_id = $this->extractArgument($params, 'memory_id');
1226: $body = $this->extractArgument($params, 'body');
1227:
1228: $endpoint = $this->endpointFactory->getEndpoint(UpdateMemory::class);
1229: $endpoint->setParams($params);
1230: $endpoint->setMemoryId($memory_id);
1231: $endpoint->setBody($body);
1232:
1233: return $this->performRequest($endpoint);
1234: }
1235:
1236: /**
1237: * Update a message.
1238: *
1239: * $params['message_id'] = (string)
1240: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1241: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1242: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1243: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1244: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1245: *
1246: * @param array $params Associative array of parameters
1247: * @return array
1248: */
1249: public function updateMessage(array $params = [])
1250: {
1251: $message_id = $this->extractArgument($params, 'message_id');
1252: $body = $this->extractArgument($params, 'body');
1253:
1254: $endpoint = $this->endpointFactory->getEndpoint(UpdateMessage::class);
1255: $endpoint->setParams($params);
1256: $endpoint->setMessageId($message_id);
1257: $endpoint->setBody($body);
1258:
1259: return $this->performRequest($endpoint);
1260: }
1261:
1262: /**
1263: * Updates a model.
1264: *
1265: * $params['model_id'] = (string)
1266: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1267: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1268: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1269: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1270: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1271: *
1272: * @param array $params Associative array of parameters
1273: * @return array
1274: */
1275: public function updateModel(array $params = [])
1276: {
1277: $model_id = $this->extractArgument($params, 'model_id');
1278: $body = $this->extractArgument($params, 'body');
1279:
1280: $endpoint = $this->endpointFactory->getEndpoint(UpdateModel::class);
1281: $endpoint->setParams($params);
1282: $endpoint->setModelId($model_id);
1283: $endpoint->setBody($body);
1284:
1285: return $this->performRequest($endpoint);
1286: }
1287:
1288: /**
1289: * Uploads model chunk.
1290: *
1291: * $params['chunk_number'] = (integer)
1292: * $params['model_id'] = (string)
1293: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1294: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1295: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1296: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1297: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1298: *
1299: * @param array $params Associative array of parameters
1300: * @return array
1301: */
1302: public function uploadChunk(array $params = [])
1303: {
1304: $chunk_number = $this->extractArgument($params, 'chunk_number');
1305: $model_id = $this->extractArgument($params, 'model_id');
1306: $body = $this->extractArgument($params, 'body');
1307:
1308: $endpoint = $this->endpointFactory->getEndpoint(UploadChunk::class);
1309: $endpoint->setParams($params);
1310: $endpoint->setChunkNumber($chunk_number);
1311: $endpoint->setModelId($model_id);
1312: $endpoint->setBody($body);
1313:
1314: return $this->performRequest($endpoint);
1315: }
1316:
1317: /**
1318: * Registers a model.
1319: *
1320: * $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)
1321: * $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)
1322: * $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)
1323: * $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.
1324: * $params['filter_path'] = (any) A comma-separated list of filters used to filter the response. Use wildcards to match any field or part of a field's name. To exclude fields, use `-`.
1325: *
1326: * @param array $params Associative array of parameters
1327: * @return array
1328: */
1329: public function uploadModel(array $params = [])
1330: {
1331: $body = $this->extractArgument($params, 'body');
1332:
1333: $endpoint = $this->endpointFactory->getEndpoint(UploadModel::class);
1334: $endpoint->setParams($params);
1335: $endpoint->setBody($body);
1336:
1337: return $this->performRequest($endpoint);
1338: }
1339:
1340: /**
1341: * $params['body'] = (string) The body of the request (Required)
1342: *
1343: * @param array $params Associative array of parameters
1344: *
1345: * @return array
1346: * The response.
1347: */
1348: public function createConnector(array $params = []): array
1349: {
1350: $body = $this->extractArgument($params, 'body');
1351: $endpoint = $this->endpointFactory->getEndpoint(CreateConnector::class);
1352: $endpoint->setParams($params);
1353: $endpoint->setBody($body);
1354:
1355: return $this->performRequest($endpoint);
1356: }
1357: /**
1358: * $params['connector_id'] = (string) The id of the connector (Required)
1359: *
1360: * @param array $params Associative array of parameters
1361: *
1362: * @return array
1363: * The response.
1364: */
1365: public function deleteConnector(array $params = []): array
1366: {
1367: $connectorId = $this->extractArgument($params, 'connector_id');
1368: $endpoint = $this->endpointFactory->getEndpoint(DeleteConnector::class);
1369: $endpoint->setParams($params);
1370: $endpoint->setConnectorId($connectorId);
1371:
1372: return $this->performRequest($endpoint);
1373: }
1374: /**
1375: * $params['model_id'] = (string) The id of the model (Required)
1376: * $params['body'] = (string) The body of the request
1377: *
1378: * @param array $params Associative array of parameters
1379: *
1380: * @return array
1381: * The response.
1382: */
1383: public function deployModel(array $params = []): array
1384: {
1385: $modelId = $this->extractArgument($params, 'model_id');
1386: $body = $this->extractArgument($params, 'body');
1387: $endpoint = $this->endpointFactory->getEndpoint(DeployModel::class);
1388: $endpoint->setParams($params);
1389: $endpoint->setModelId($modelId);
1390: if ($body) {
1391: $endpoint->setBody($body);
1392: }
1393:
1394: return $this->performRequest($endpoint);
1395: }
1396: /**
1397: * $params['id'] = (string) The id of the connector (Required)
1398: *
1399: * @param array $params Associative array of parameters
1400: *
1401: * @return array
1402: * The response.
1403: */
1404: public function getConnector(array $params = []): array
1405: {
1406: $id = $this->extractArgument($params, 'id');
1407: $connector_id = $this->extractArgument($params, 'connector_id');
1408: $endpoint = $this->endpointFactory->getEndpoint(GetConnector::class);
1409: $endpoint->setParams($params);
1410: $endpoint->setId($id);
1411: $endpoint->setConnectorId($connector_id);
1412:
1413: return $this->performRequest($endpoint);
1414: }
1415: /**
1416: * $params['body'] = (string) The body of the request
1417: *
1418: * @param array $params Associative array of parameters
1419: *
1420: * @return array
1421: * The response.
1422: */
1423: public function getConnectors(array $params = []): array
1424: {
1425: if (!isset($params['body'])) {
1426: $params['body'] = [
1427: 'query' => [
1428: 'match_all' => new \StdClass(),
1429: ],
1430: 'size' => 1000,
1431: ];
1432: }
1433: $body = $this->extractArgument($params, 'body');
1434: $endpoint = $this->endpointFactory->getEndpoint(GetConnectors::class);
1435: $endpoint->setBody($body);
1436:
1437: return $this->performRequest($endpoint);
1438: }
1439: /**
1440: * $params['body'] = (string) The body of the request
1441: *
1442: * @param array $params Associative array of parameters
1443: *
1444: * @return array
1445: * The response.
1446: */
1447: public function getModelGroups(array $params = []): array
1448: {
1449: if (!isset($params['body'])) {
1450: $params['body'] = [
1451: 'query' => [
1452: 'match_all' => new \StdClass(),
1453: ],
1454: 'size' => 1000,
1455: ];
1456: }
1457: $body = $this->extractArgument($params, 'body');
1458: $endpoint = $this->endpointFactory->getEndpoint(GetModelGroups::class);
1459: $endpoint->setBody($body);
1460:
1461: return $this->performRequest($endpoint);
1462: }
1463: /**
1464: * $params['id'] = (string) The id of the model (Required)
1465: *
1466: * @param array $params Associative array of parameters
1467: *
1468: * @return array
1469: * The response.
1470: */
1471: public function getModel(array $params = []): array
1472: {
1473: $id = $this->extractArgument($params, 'id');
1474: $model_id = $this->extractArgument($params, 'model_id');
1475: $endpoint = $this->endpointFactory->getEndpoint(GetModel::class);
1476: $endpoint->setParams($params);
1477: $endpoint->setId($id);
1478: $endpoint->setModelId($model_id);
1479:
1480: return $this->performRequest($endpoint);
1481: }
1482: /**
1483: * Proxy function to getModels() to prevent BC break.
1484: * This API will be removed in a future version. Use 'searchModels' API instead.
1485: */
1486: public function getModels(array $params = [])
1487: {
1488: if (!isset($params['body'])) {
1489: $params['body'] = [
1490: 'query' => [
1491: 'match_all' => new \StdClass(),
1492: ],
1493: 'size' => 1000,
1494: ];
1495: }
1496:
1497: return $this->searchModels($params);
1498: }
1499: /**
1500: * $params['id'] = (string) The id of the model (Required)
1501: * $params['body'] = (string) The body of the request
1502: *
1503: * @param array $params Associative array of parameters
1504: *
1505: * @return array
1506: * The response.
1507: */
1508: public function predict(array $params = []): array
1509: {
1510: $id = $this->extractArgument($params, 'id');
1511: $body = $this->extractArgument($params, 'body');
1512: $algorithm_name = $this->extractArgument($params, 'algorithm_name');
1513: $model_id = $this->extractArgument($params, 'model_id');
1514:
1515: $endpoint = $this->endpointFactory->getEndpoint(Predict::class);
1516: $endpoint->setParams($params)
1517: ->setId($id)
1518: ->setBody($body)
1519: ->setAlgorithmName($algorithm_name)
1520: ->setModelId($model_id);
1521:
1522: return $this->performRequest($endpoint);
1523: }
1524: /**
1525: * $params['model_id'] = (string) The id of the model (Required)
1526: * $params['body'] = (string) The body of the request
1527: *
1528: * @param array $params Associative array of parameters
1529: *
1530: * @return array
1531: * The response.
1532: */
1533: public function undeployModel(array $params = []): array
1534: {
1535: $modelId = $this->extractArgument($params, 'model_id');
1536: $body = $this->extractArgument($params, 'body');
1537: $endpoint = $this->endpointFactory->getEndpoint(UndeployModel::class);
1538: $endpoint->setParams($params);
1539: $endpoint->setModelId($modelId);
1540: if ($body) {
1541: $endpoint->setBody($body);
1542: }
1543:
1544: return $this->performRequest($endpoint);
1545: }
1546: /**
1547: * $params['id'] = (string) The id of the model group (Required)
1548: * $params['body'] = (array) The body of the request (Required)
1549: *
1550: * @param array $params Associative array of parameters
1551: *
1552: * @return array
1553: * The response.
1554: */
1555: public function updateModelGroup(array $params = []): array
1556: {
1557: $id = $this->extractArgument($params, 'id');
1558: $model_group_id = $this->extractArgument($params, 'model_group_id');
1559: $body = $this->extractArgument($params, 'body');
1560: $endpoint = $this->endpointFactory->getEndpoint(UpdateModelGroup::class);
1561: $endpoint->setParams($params);
1562: $endpoint->setBody($body);
1563: $endpoint->setId($id);
1564: $endpoint->setModelGroupId($model_group_id);
1565:
1566: return $this->performRequest($endpoint);
1567: }
1568: }
1569:
API documentation generated by ApiGen v7.0.0-alpha.4