File OpenSearch/Namespaces/SecurityNamespace.php

* $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 `-`.

113:

*

114:

* @param array $params Associative array of parameters

115:

* @return array

116:

*/

117:

public function authinfo(array $params = [])

118:

{

119:

$endpoint = $this->endpointFactory->getEndpoint(Authinfo::class);

120:

$endpoint->setParams($params);

121:

122:

return $this->performRequest($endpoint);

}

/**

* Returns the authorization token for the current user.

127:

*

128:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

129:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

130:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

131:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

132:

* $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 `-`.

133:

*

134:

* @param array $params Associative array of parameters

135:

* @return array

136:

*/

137:

public function authtoken(array $params = [])

138:

{

139:

$endpoint = $this->endpointFactory->getEndpoint(Authtoken::class);

140:

$endpoint->setParams($params);

141:

142:

return $this->performRequest($endpoint);

}

/**

* Not supported for the Cache API.

147:

*

148:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

149:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

150:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

151:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

152:

* $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 `-`.

153:

*

154:

* @param array $params Associative array of parameters

155:

* @return array

156:

*/

157:

public function cache(array $params = [])

158:

{

159:

$endpoint = $this->endpointFactory->getEndpoint(Cache::class);

160:

$endpoint->setParams($params);

161:

162:

return $this->performRequest($endpoint);

}

/**

* Checks whether or not an upgrade can be performed and which security resources can be updated.

167:

*

168:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

169:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

170:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

171:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

172:

* $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 `-`.

173:

*

174:

* @param array $params Associative array of parameters

175:

* @return array

176:

*/

177:

public function configUpgradeCheck(array $params = [])

178:

{

179:

$endpoint = $this->endpointFactory->getEndpoint(ConfigUpgradeCheck::class);

180:

$endpoint->setParams($params);

181:

182:

return $this->performRequest($endpoint);

}

/**

* Assists the cluster operator with upgrading missing default values and stale default definitions.

187:

*

188:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

189:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

190:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

191:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

192:

* $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 `-`.

193:

*

194:

* @param array $params Associative array of parameters

195:

* @return array

196:

*/

197:

public function configUpgradePerform(array $params = [])

198:

{

199:

$body = $this->extractArgument($params, 'body');

200:

201:

$endpoint = $this->endpointFactory->getEndpoint(ConfigUpgradePerform::class);

202:

$endpoint->setParams($params);

203:

$endpoint->setBody($body);

204:

205:

return $this->performRequest($endpoint);

}

/**

* Creates or replaces APIs permitted for users on the allow list. Requires a super admin certificate or REST API permissions.

210:

*

211:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

212:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

213:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

214:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

215:

* $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 `-`.

216:

*

217:

* @param array $params Associative array of parameters

218:

* @return array

219:

*/

220:

public function createAllowlist(array $params = [])

221:

{

222:

$body = $this->extractArgument($params, 'body');

223:

224:

$endpoint = $this->endpointFactory->getEndpoint(CreateAllowlist::class);

225:

$endpoint->setParams($params);

226:

$endpoint->setBody($body);

227:

228:

return $this->performRequest($endpoint);

}

/**

* Creates or replaces the multi-tenancy configuration. Requires super admin or REST API permissions.

233:

*

234:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

235:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

236:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

237:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

238:

* $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 `-`.

239:

*

240:

* @param array $params Associative array of parameters

241:

* @return array

242:

*/

243:

public function createUpdateTenancyConfig(array $params = [])

244:

{

245:

$body = $this->extractArgument($params, 'body');

246:

247:

$endpoint = $this->endpointFactory->getEndpoint(CreateUpdateTenancyConfig::class);

248:

$endpoint->setParams($params);

249:

$endpoint->setBody($body);

250:

251:

return $this->performRequest($endpoint);

}

/**

* Creates or replaces the specified user. Legacy API.

256:

*

257:

* $params['username'] = (string) The name of the user to create. (Required)

258:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

259:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

260:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

261:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

262:

* $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 `-`.

263:

*

264:

* @param array $params Associative array of parameters

265:

* @return array

266:

*/

267:

public function createUserLegacy(array $params = [])

268:

{

269:

$username = $this->extractArgument($params, 'username');

270:

$body = $this->extractArgument($params, 'body');

271:

272:

$endpoint = $this->endpointFactory->getEndpoint(CreateUserLegacy::class);

273:

$endpoint->setParams($params);

274:

$endpoint->setUsername($username);

275:

$endpoint->setBody($body);

276:

277:

return $this->performRequest($endpoint);

}

/**

* Deletes the specified action group.

282:

*

283:

* $params['action_group'] = (string) The name of the action group to delete. (Required)

284:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

285:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

286:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

287:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

288:

* $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 `-`.

289:

*

290:

* @param array $params Associative array of parameters

291:

* @return array

292:

*/

293:

public function deleteActionGroup(array $params = [])

294:

{

295:

$action_group = $this->extractArgument($params, 'action_group');

296:

297:

$endpoint = $this->endpointFactory->getEndpoint(DeleteActionGroup::class);

298:

$endpoint->setParams($params);

299:

$endpoint->setActionGroup($action_group);

300:

301:

return $this->performRequest($endpoint);

}

/**

* Deletes all distinguished names in the specified cluster or node allowlist. Requires super admin or REST API permissions.

306:

*

307:

* $params['cluster_name'] = (string) The cluster name to delete from list of distinguished names. (Required)

308:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

309:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

310:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

311:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

312:

* $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 `-`.

313:

*

314:

* @param array $params Associative array of parameters

315:

* @return array

316:

*/

317:

public function deleteDistinguishedName(array $params = [])

318:

{

319:

$cluster_name = $this->extractArgument($params, 'cluster_name');

320:

321:

$endpoint = $this->endpointFactory->getEndpoint(DeleteDistinguishedName::class);

322:

$endpoint->setParams($params);

323:

$endpoint->setClusterName($cluster_name);

324:

325:

return $this->performRequest($endpoint);

}

/**

* Deletes the specified role.

330:

*

331:

* $params['role'] = (string) The name of the role to delete. (Required)

332:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

333:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

334:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

335:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

336:

* $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 `-`.

337:

*

338:

* @param array $params Associative array of parameters

339:

* @return array

340:

*/

341:

public function deleteRole(array $params = [])

342:

{

343:

$role = $this->extractArgument($params, 'role');

344:

345:

$endpoint = $this->endpointFactory->getEndpoint(DeleteRole::class);

346:

$endpoint->setParams($params);

347:

$endpoint->setRole($role);

348:

349:

return $this->performRequest($endpoint);

}

/**

* Deletes the specified role mapping.

354:

*

355:

* $params['role'] = (string) The name of the role for which to delete the role's mappings. (Required)

356:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

357:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

358:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

359:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

360:

* $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 `-`.

361:

*

362:

* @param array $params Associative array of parameters

363:

* @return array

364:

*/

365:

public function deleteRoleMapping(array $params = [])

366:

{

367:

$role = $this->extractArgument($params, 'role');

368:

369:

$endpoint = $this->endpointFactory->getEndpoint(DeleteRoleMapping::class);

370:

$endpoint->setParams($params);

371:

$endpoint->setRole($role);

372:

373:

return $this->performRequest($endpoint);

}

/**

* Deletes the specified tenant.

378:

*

379:

* $params['tenant'] = (string) The name of the tenant to delete. (Required)

380:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

381:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

382:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

383:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

384:

* $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 `-`.

385:

*

386:

* @param array $params Associative array of parameters

387:

* @return array

388:

*/

389:

public function deleteTenant(array $params = [])

390:

{

391:

$tenant = $this->extractArgument($params, 'tenant');

392:

393:

$endpoint = $this->endpointFactory->getEndpoint(DeleteTenant::class);

394:

$endpoint->setParams($params);

395:

$endpoint->setTenant($tenant);

396:

397:

return $this->performRequest($endpoint);

}

/**

* Deletes the specified internal user.

402:

*

403:

* $params['username'] = (string) The name of the user to delete. (Required)

404:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

405:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

406:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

407:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

408:

* $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 `-`.

409:

*

410:

* @param array $params Associative array of parameters

411:

* @return array

412:

*/

413:

public function deleteUser(array $params = [])

414:

{

415:

$username = $this->extractArgument($params, 'username');

416:

417:

$endpoint = $this->endpointFactory->getEndpoint(DeleteUser::class);

418:

$endpoint->setParams($params);

419:

$endpoint->setUsername($username);

420:

421:

return $this->performRequest($endpoint);

}

/**

* Delete the specified user. Legacy API.

426:

*

427:

* $params['username'] = (string) The name of the user to delete. (Required)

428:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

429:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

430:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

431:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

432:

* $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 `-`.

433:

*

434:

* @param array $params Associative array of parameters

435:

* @return array

436:

*/

437:

public function deleteUserLegacy(array $params = [])

438:

{

439:

$username = $this->extractArgument($params, 'username');

440:

441:

$endpoint = $this->endpointFactory->getEndpoint(DeleteUserLegacy::class);

442:

$endpoint->setParams($params);

443:

$endpoint->setUsername($username);

444:

445:

return $this->performRequest($endpoint);

}

/**

* Flushes the Security plugin's user, authentication, and authorization cache.

450:

*

451:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

452:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

453:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

454:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

455:

* $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 `-`.

456:

*

457:

* @param array $params Associative array of parameters

458:

* @return array

459:

*/

460:

public function flushCache(array $params = [])

461:

{

462:

$endpoint = $this->endpointFactory->getEndpoint(FlushCache::class);

463:

$endpoint->setParams($params);

464:

465:

return $this->performRequest($endpoint);

}

/**

* Generates a `On-Behalf-Of` token for the current user.

470:

*

471:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

472:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

473:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

474:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

475:

* $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 `-`.

476:

*

477:

* @param array $params Associative array of parameters

478:

* @return array

479:

*/

480:

public function generateOboToken(array $params = [])

481:

{

482:

$body = $this->extractArgument($params, 'body');

483:

484:

$endpoint = $this->endpointFactory->getEndpoint(GenerateOboToken::class);

485:

$endpoint->setParams($params);

486:

$endpoint->setBody($body);

487:

488:

return $this->performRequest($endpoint);

}

/**

* Generates an authorization token for the specified user.

493:

*

494:

* $params['username'] = (string) The name of the user for whom to issue an authorization token. (Required)

495:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

496:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

497:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

498:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

499:

* $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 `-`.

500:

*

501:

* @param array $params Associative array of parameters

502:

* @return array

503:

*/

504:

public function generateUserToken(array $params = [])

505:

{

506:

$username = $this->extractArgument($params, 'username');

507:

508:

$endpoint = $this->endpointFactory->getEndpoint(GenerateUserToken::class);

509:

$endpoint->setParams($params);

510:

$endpoint->setUsername($username);

511:

512:

return $this->performRequest($endpoint);

}

/**

* Generates authorization token for the given user. Legacy API. Not Implemented.

517:

*

518:

* $params['username'] = (string) The name of the user for whom to issue an authorization token. (Required)

519:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

520:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

521:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

522:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

523:

* $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 `-`.

524:

*

525:

* @param array $params Associative array of parameters

526:

* @return array

527:

*/

528:

public function generateUserTokenLegacy(array $params = [])

529:

{

530:

$username = $this->extractArgument($params, 'username');

531:

532:

$endpoint = $this->endpointFactory->getEndpoint(GenerateUserTokenLegacy::class);

533:

$endpoint->setParams($params);

534:

$endpoint->setUsername($username);

535:

536:

return $this->performRequest($endpoint);

}

/**

* Returns account information for the current user.

541:

*

542:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

543:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

544:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

545:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

546:

* $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 `-`.

547:

*

548:

* @param array $params Associative array of parameters

549:

* @return array

550:

*/

551:

public function getAccountDetails(array $params = [])

552:

{

553:

$endpoint = $this->endpointFactory->getEndpoint(GetAccountDetails::class);

554:

$endpoint->setParams($params);

555:

556:

return $this->performRequest($endpoint);

}

/**

* Retrieves one action group.

561:

*

562:

* $params['action_group'] = (string) The name of the action group to retrieve. (Required)

563:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

564:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

565:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

566:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

567:

* $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 `-`.

568:

*

569:

* @param array $params Associative array of parameters

570:

* @return array

571:

*/

572:

public function getActionGroup(array $params = [])

573:

{

574:

$action_group = $this->extractArgument($params, 'action_group');

575:

576:

$endpoint = $this->endpointFactory->getEndpoint(GetActionGroup::class);

577:

$endpoint->setParams($params);

578:

$endpoint->setActionGroup($action_group);

579:

580:

return $this->performRequest($endpoint);

}

/**

* Retrieves the cluster security certificates.

585:

*

586:

* $params['cert_type'] = (string) The type of certificates (`HTTP`, `TRANSPORT`, or `ALL`) to retrieve from all nodes.

587:

* $params['timeout'] = (string) The maximum duration, in seconds, to spend retrieving certificates from all nodes before a timeout.

588:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

589:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

590:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

591:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

592:

* $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 `-`.

593:

*

594:

* @param array $params Associative array of parameters

595:

* @return array

596:

*/

597:

public function getAllCertificates(array $params = [])

598:

{

599:

$endpoint = $this->endpointFactory->getEndpoint(GetAllCertificates::class);

600:

$endpoint->setParams($params);

601:

602:

return $this->performRequest($endpoint);

}

/**

* Retrieves the current list of allowed APIs accessible to a normal user.

607:

*

608:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

609:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

610:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

611:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

612:

* $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 `-`.

613:

*

614:

* @param array $params Associative array of parameters

615:

* @return array

616:

*/

617:

public function getAllowlist(array $params = [])

618:

{

619:

$endpoint = $this->endpointFactory->getEndpoint(GetAllowlist::class);

620:

$endpoint->setParams($params);

621:

622:

return $this->performRequest($endpoint);

}

/**

* Retrieves the audit configuration.

627:

*

628:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

629:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

630:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

631:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

632:

* $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 `-`.

633:

*

634:

* @param array $params Associative array of parameters

635:

* @return array

636:

*/

637:

public function getAuditConfiguration(array $params = [])

638:

{

639:

$endpoint = $this->endpointFactory->getEndpoint(GetAuditConfiguration::class);

640:

$endpoint->setParams($params);

641:

642:

return $this->performRequest($endpoint);

}

/**

* Retrieves the cluster security certificates.

647:

*

648:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

649:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

650:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

651:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

652:

* $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 `-`.

653:

*

654:

* @param array $params Associative array of parameters

655:

* @return array

656:

*/

657:

public function getCertificates(array $params = [])

658:

{

659:

$endpoint = $this->endpointFactory->getEndpoint(GetCertificates::class);

660:

$endpoint->setParams($params);

661:

662:

return $this->performRequest($endpoint);

}

/**

* Returns the current Security plugin configuration in a JSON format.

667:

*

668:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

669:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

670:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

671:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

672:

* $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 `-`.

673:

*

674:

* @param array $params Associative array of parameters

675:

* @return array

676:

*/

677:

public function getConfiguration(array $params = [])

678:

{

679:

$endpoint = $this->endpointFactory->getEndpoint(GetConfiguration::class);

680:

$endpoint->setParams($params);

681:

682:

return $this->performRequest($endpoint);

}

/**

* Retrieves the current values for dynamic security settings for OpenSearch Dashboards.

687:

*

688:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

689:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

690:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

691:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

692:

* $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 `-`.

693:

*

694:

* @param array $params Associative array of parameters

695:

* @return array

696:

*/

697:

public function getDashboardsInfo(array $params = [])

698:

{

699:

$endpoint = $this->endpointFactory->getEndpoint(GetDashboardsInfo::class);

700:

$endpoint->setParams($params);

701:

702:

return $this->performRequest($endpoint);

}

/**

* Retrieves all node distinguished names. Requires super admin or REST API permissions.

707:

*

708:

* $params['cluster_name'] = (string) The name of the cluster to retrieve that cluster's nodes DN settings. (Required)

709:

* $params['show_all'] = (boolean) Whether to include or exclude any static node's DN settings from the final result.

710:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

711:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

712:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

713:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

714:

* $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 `-`.

715:

*

716:

* @param array $params Associative array of parameters

717:

* @return array

718:

*/

719:

public function getDistinguishedName(array $params = [])

720:

{

721:

$cluster_name = $this->extractArgument($params, 'cluster_name');

722:

723:

$endpoint = $this->endpointFactory->getEndpoint(GetDistinguishedName::class);

724:

$endpoint->setParams($params);

725:

$endpoint->setClusterName($cluster_name);

726:

727:

return $this->performRequest($endpoint);

}

/**

* Retrieves the specified node's security certificates.

732:

*

733:

* $params['node_id'] = (string) The node ID to retrieve certificates for.

734:

* $params['cert_type'] = (string) The type of certificates (`HTTP`, `TRANSPORT`, or `ALL`) to retrieve from a node.

735:

* $params['timeout'] = (string) The maximum duration, in seconds, to spend retrieving certificates from all nodes before a timeout.

736:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

737:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

738:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

739:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

740:

* $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 `-`.

741:

*

742:

* @param array $params Associative array of parameters

743:

* @return array

744:

*/

745:

public function getNodeCertificates(array $params = [])

746:

{

747:

$node_id = $this->extractArgument($params, 'node_id');

748:

749:

$endpoint = $this->endpointFactory->getEndpoint(GetNodeCertificates::class);

750:

$endpoint->setParams($params);

751:

$endpoint->setNodeId($node_id);

752:

753:

return $this->performRequest($endpoint);

}

/**

* Retrieves the evaluated REST API permissions for the currently logged in user.

758:

*

759:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

760:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

761:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

762:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

763:

* $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 `-`.

764:

*

765:

* @param array $params Associative array of parameters

766:

* @return array

767:

*/

768:

public function getPermissionsInfo(array $params = [])

769:

{

770:

$endpoint = $this->endpointFactory->getEndpoint(GetPermissionsInfo::class);

771:

$endpoint->setParams($params);

772:

773:

return $this->performRequest($endpoint);

}

/**

* Retrieves one role.

778:

*

779:

* $params['role'] = (string) The name of the role to retrieve. (Required)

780:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

781:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

782:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

783:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

784:

* $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 `-`.

785:

*

786:

* @param array $params Associative array of parameters

787:

* @return array

788:

*/

789:

public function getRole(array $params = [])

790:

{

791:

$role = $this->extractArgument($params, 'role');

792:

793:

$endpoint = $this->endpointFactory->getEndpoint(GetRole::class);

794:

$endpoint->setParams($params);

795:

$endpoint->setRole($role);

796:

797:

return $this->performRequest($endpoint);

}

/**

* Retrieves the specified role mapping.

802:

*

803:

* $params['role'] = (string) The name of the role mapping to retrieve. (Required)

804:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

805:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

806:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

807:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

808:

* $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 `-`.

809:

*

810:

* @param array $params Associative array of parameters

811:

* @return array

812:

*/

813:

public function getRoleMapping(array $params = [])

814:

{

815:

$role = $this->extractArgument($params, 'role');

816:

817:

$endpoint = $this->endpointFactory->getEndpoint(GetRoleMapping::class);

818:

$endpoint->setParams($params);

819:

$endpoint->setRole($role);

820:

821:

return $this->performRequest($endpoint);

}

/**

* Retrieves information about the SSL configuration.

826:

*

827:

* $params['show_dn'] = (any) Whether to include all domain names in the response.

828:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

829:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

830:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

831:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

832:

* $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 `-`.

833:

*

834:

* @param array $params Associative array of parameters

835:

* @return array

836:

*/

837:

public function getSslinfo(array $params = [])

838:

{

839:

$endpoint = $this->endpointFactory->getEndpoint(GetSslinfo::class);

840:

$endpoint->setParams($params);

841:

842:

return $this->performRequest($endpoint);

}

/**

* Retrieves the multi-tenancy configuration. Requires super admin or REST API permissions.

847:

*

848:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

849:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

850:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

851:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

852:

* $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 `-`.

853:

*

854:

* @param array $params Associative array of parameters

855:

* @return array

856:

*/

857:

public function getTenancyConfig(array $params = [])

858:

{

859:

$endpoint = $this->endpointFactory->getEndpoint(GetTenancyConfig::class);

860:

$endpoint->setParams($params);

861:

862:

return $this->performRequest($endpoint);

}

/**

* Retrieves the specified tenant.

867:

*

868:

* $params['tenant'] = (string) The name of the tenant to retrieve. (Required)

869:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

870:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

871:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

872:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

873:

* $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 `-`.

874:

*

875:

* @param array $params Associative array of parameters

876:

* @return array

877:

*/

878:

public function getTenant(array $params = [])

879:

{

880:

$tenant = $this->extractArgument($params, 'tenant');

881:

882:

$endpoint = $this->endpointFactory->getEndpoint(GetTenant::class);

883:

$endpoint->setParams($params);

884:

$endpoint->setTenant($tenant);

885:

886:

return $this->performRequest($endpoint);

}

/**

* Retrieve information about the specified internal user.

891:

*

892:

* $params['username'] = (string) The name of the user to retrieve. (Required)

893:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

894:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

895:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

896:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

897:

* $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 `-`.

898:

*

899:

* @param array $params Associative array of parameters

900:

* @return array

901:

*/

902:

public function getUser(array $params = [])

903:

{

904:

$username = $this->extractArgument($params, 'username');

905:

906:

$endpoint = $this->endpointFactory->getEndpoint(GetUser::class);

907:

$endpoint->setParams($params);

908:

$endpoint->setUsername($username);

909:

910:

return $this->performRequest($endpoint);

}

/**

* Retrieve one user. Legacy API.

915:

*

916:

* $params['username'] = (string) The name of the user to retrieve. (Required)

917:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

918:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

919:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

920:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

921:

* $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 `-`.

922:

*

923:

* @param array $params Associative array of parameters

924:

* @return array

925:

*/

926:

public function getUserLegacy(array $params = [])

927:

{

928:

$username = $this->extractArgument($params, 'username');

929:

930:

$endpoint = $this->endpointFactory->getEndpoint(GetUserLegacy::class);

931:

$endpoint->setParams($params);

932:

$endpoint->setUsername($username);

933:

934:

return $this->performRequest($endpoint);

}

/**

* Retrieve all internal users. Legacy API.

939:

*

940:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

941:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

942:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

943:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

944:

* $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 `-`.

945:

*

946:

* @param array $params Associative array of parameters

947:

* @return array

948:

*/

949:

public function getUsersLegacy(array $params = [])

950:

{

951:

$endpoint = $this->endpointFactory->getEndpoint(GetUsersLegacy::class);

952:

$endpoint->setParams($params);

953:

954:

return $this->performRequest($endpoint);

}

/**

* Checks to see if the Security plugin is running.

959:

*

960:

* $params['mode'] = (string) A flag that determines whether to consider the security status before returning a response for a health query response. For example, `strict` mode indicates service should check the Security plugin status.

961:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

962:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

963:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

964:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

965:

* $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 `-`.

966:

*

967:

* @param array $params Associative array of parameters

968:

* @return array

969:

*/

970:

public function health(array $params = [])

971:

{

972:

$endpoint = $this->endpointFactory->getEndpoint(Health::class);

973:

$endpoint->setParams($params);

974:

975:

return $this->performRequest($endpoint);

}

/**

* Migrates the security configuration from v6 to v7.

980:

*

981:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

982:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

983:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

984:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

985:

* $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 `-`.

986:

*

987:

* @param array $params Associative array of parameters

988:

* @return array

989:

*/

990:

public function migrate(array $params = [])

991:

{

992:

$endpoint = $this->endpointFactory->getEndpoint(Migrate::class);

993:

$endpoint->setParams($params);

994:

995:

return $this->performRequest($endpoint);

}

/**

* Updates the individual attributes of an action group.

1000:

*

1001:

* $params['action_group'] = (string) The name of the action group to update. (Required)

1002:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1003:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1004:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1005:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1006:

* $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 `-`.

1007:

*

1008:

* @param array $params Associative array of parameters

1009:

* @return array

1010:

*/

1011:

public function patchActionGroup(array $params = [])

1012:

{

1013:

$action_group = $this->extractArgument($params, 'action_group');

1014:

$body = $this->extractArgument($params, 'body');

1015:

1016:

$endpoint = $this->endpointFactory->getEndpoint(PatchActionGroup::class);

1017:

$endpoint->setParams($params);

1018:

$endpoint->setActionGroup($action_group);

1019:

$endpoint->setBody($body);

1020:

1021:

return $this->performRequest($endpoint);

}

/**

* Updates the current list of APIs accessible for users on the allow list.

1026:

*

1027:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1028:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1029:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1030:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1031:

* $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 `-`.

1032:

*

1033:

* @param array $params Associative array of parameters

1034:

* @return array

1035:

*/

1036:

public function patchAllowlist(array $params = [])

1037:

{

1038:

$body = $this->extractArgument($params, 'body');

1039:

1040:

$endpoint = $this->endpointFactory->getEndpoint(PatchAllowlist::class);

1041:

$endpoint->setParams($params);

1042:

$endpoint->setBody($body);

1043:

1044:

return $this->performRequest($endpoint);

}

/**

* Updates the specified fields in the audit configuration.

1049:

*

1050:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1051:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1052:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1053:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1054:

* $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 `-`.

1055:

*

1056:

* @param array $params Associative array of parameters

1057:

* @return array

1058:

*/

1059:

public function patchAuditConfiguration(array $params = [])

1060:

{

1061:

$body = $this->extractArgument($params, 'body');

1062:

1063:

$endpoint = $this->endpointFactory->getEndpoint(PatchAuditConfiguration::class);

1064:

$endpoint->setParams($params);

1065:

$endpoint->setBody($body);

1066:

1067:

return $this->performRequest($endpoint);

}

/**

* Updates the existing security configuration using the REST API. Requires super admin or REST API permissions.

1072:

*

1073:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1074:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1075:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1076:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1077:

* $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 `-`.

1078:

*

1079:

* @param array $params Associative array of parameters

1080:

* @return array

1081:

*/

1082:

public function patchConfiguration(array $params = [])

1083:

{

1084:

$body = $this->extractArgument($params, 'body');

1085:

1086:

$endpoint = $this->endpointFactory->getEndpoint(PatchConfiguration::class);

1087:

$endpoint->setParams($params);

1088:

$endpoint->setBody($body);

1089:

1090:

return $this->performRequest($endpoint);

}

/**

* Updates the distinguished cluster name for the specified cluster. Requires super admin or REST API permissions.

1095:

*

1096:

* $params['cluster_name'] = (string) The cluster name to update the `nodesDn` value. (Required)

1097:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1098:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1099:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1100:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1101:

* $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 `-`.

1102:

*

1103:

* @param array $params Associative array of parameters

1104:

* @return array

1105:

*/

1106:

public function patchDistinguishedName(array $params = [])

1107:

{

1108:

$cluster_name = $this->extractArgument($params, 'cluster_name');

1109:

$body = $this->extractArgument($params, 'body');

1110:

1111:

$endpoint = $this->endpointFactory->getEndpoint(PatchDistinguishedName::class);

1112:

$endpoint->setParams($params);

1113:

$endpoint->setClusterName($cluster_name);

1114:

$endpoint->setBody($body);

1115:

1116:

return $this->performRequest($endpoint);

}

/**

* Bulk updates specified node distinguished names. Requires super admin or REST API permissions.

1121:

*

1122:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1123:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1124:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1125:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1126:

* $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 `-`.

1127:

*

1128:

* @param array $params Associative array of parameters

1129:

* @return array

1130:

*/

1131:

public function patchDistinguishedNames(array $params = [])

1132:

{

1133:

$body = $this->extractArgument($params, 'body');

1134:

1135:

$endpoint = $this->endpointFactory->getEndpoint(PatchDistinguishedNames::class);

1136:

$endpoint->setParams($params);

1137:

$endpoint->setBody($body);

1138:

1139:

return $this->performRequest($endpoint);

}

/**

* Updates the individual attributes of a role.

1144:

*

1145:

* $params['role'] = (string) The name of the role to update. (Required)

1146:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1147:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1148:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1149:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1150:

* $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 `-`.

1151:

*

1152:

* @param array $params Associative array of parameters

1153:

* @return array

1154:

*/

1155:

public function patchRole(array $params = [])

1156:

{

1157:

$role = $this->extractArgument($params, 'role');

1158:

$body = $this->extractArgument($params, 'body');

1159:

1160:

$endpoint = $this->endpointFactory->getEndpoint(PatchRole::class);

1161:

$endpoint->setParams($params);

1162:

$endpoint->setRole($role);

1163:

$endpoint->setBody($body);

1164:

1165:

return $this->performRequest($endpoint);

}

/**

* Updates the individual attributes of a role mapping.

1170:

*

1171:

* $params['role'] = (string) The name of the role to update a role mapping for (Required)

1172:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1173:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1174:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1175:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1176:

* $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 `-`.

1177:

*

1178:

* @param array $params Associative array of parameters

1179:

* @return array

1180:

*/

1181:

public function patchRoleMapping(array $params = [])

1182:

{

1183:

$role = $this->extractArgument($params, 'role');

1184:

$body = $this->extractArgument($params, 'body');

1185:

1186:

$endpoint = $this->endpointFactory->getEndpoint(PatchRoleMapping::class);

1187:

$endpoint->setParams($params);

1188:

$endpoint->setRole($role);

1189:

$endpoint->setBody($body);

1190:

1191:

return $this->performRequest($endpoint);

}

/**

* Adds, deletes, or modifies a single tenant.

1196:

*

1197:

* $params['tenant'] = (string) The name of the tenant to update. (Required)

1198:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1199:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1200:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1201:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1202:

* $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 `-`.

1203:

*

1204:

* @param array $params Associative array of parameters

1205:

* @return array

1206:

*/

1207:

public function patchTenant(array $params = [])

1208:

{

1209:

$tenant = $this->extractArgument($params, 'tenant');

1210:

$body = $this->extractArgument($params, 'body');

1211:

1212:

$endpoint = $this->endpointFactory->getEndpoint(PatchTenant::class);

1213:

$endpoint->setParams($params);

1214:

$endpoint->setTenant($tenant);

1215:

$endpoint->setBody($body);

1216:

1217:

return $this->performRequest($endpoint);

}

/**

* Updates individual attributes for an internal user.

1222:

*

1223:

* $params['username'] = (string) The name of the user to update. (Required)

1224:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1225:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1226:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1227:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1228:

* $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 `-`.

1229:

*

1230:

* @param array $params Associative array of parameters

1231:

* @return array

1232:

*/

1233:

public function patchUser(array $params = [])

1234:

{

1235:

$username = $this->extractArgument($params, 'username');

1236:

$body = $this->extractArgument($params, 'body');

1237:

1238:

$endpoint = $this->endpointFactory->getEndpoint(PatchUser::class);

1239:

$endpoint->setParams($params);

1240:

$endpoint->setUsername($username);

1241:

$endpoint->setBody($body);

1242:

1243:

return $this->performRequest($endpoint);

}

/**

* Retrieves the current values for dynamic security settings for OpenSearch Dashboards.

1248:

*

1249:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1250:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1251:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1252:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1253:

* $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 `-`.

1254:

*

1255:

* @param array $params Associative array of parameters

1256:

* @return array

1257:

*/

1258:

public function postDashboardsInfo(array $params = [])

1259:

{

1260:

$endpoint = $this->endpointFactory->getEndpoint(PostDashboardsInfo::class);

1261:

$endpoint->setParams($params);

1262:

1263:

return $this->performRequest($endpoint);

}

/**

* Reloads the HTTP communication certificates.

1268:

*

1269:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1270:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1271:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1272:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1273:

* $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 `-`.

1274:

*

1275:

* @param array $params Associative array of parameters

1276:

* @return array

1277:

*/

1278:

public function reloadHttpCertificates(array $params = [])

1279:

{

1280:

$endpoint = $this->endpointFactory->getEndpoint(ReloadHttpCertificates::class);

1281:

$endpoint->setParams($params);

1282:

1283:

return $this->performRequest($endpoint);

}

/**

* Reloads the transport communication certificates.

1288:

*

1289:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1290:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1291:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1292:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1293:

* $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 `-`.

1294:

*

1295:

* @param array $params Associative array of parameters

1296:

* @return array

1297:

*/

1298:

public function reloadTransportCertificates(array $params = [])

1299:

{

1300:

$endpoint = $this->endpointFactory->getEndpoint(ReloadTransportCertificates::class);

1301:

$endpoint->setParams($params);

1302:

1303:

return $this->performRequest($endpoint);

}

/**

* Retrieves the names of current tenants. Requires super admin or `kibanaserver` permissions.

1308:

*

1309:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1310:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1311:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1312:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1313:

* $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 `-`.

1314:

*

1315:

* @param array $params Associative array of parameters

1316:

* @return array

1317:

*/

1318:

public function tenantInfo(array $params = [])

1319:

{

1320:

$endpoint = $this->endpointFactory->getEndpoint(TenantInfo::class);

1321:

$endpoint->setParams($params);

1322:

1323:

return $this->performRequest($endpoint);

}

/**

* Updates the audit configuration.

1328:

*

1329:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1330:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1331:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1332:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1333:

* $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 `-`.

1334:

*

1335:

* @param array $params Associative array of parameters

1336:

* @return array

1337:

*/

1338:

public function updateAuditConfiguration(array $params = [])

1339:

{

1340:

$body = $this->extractArgument($params, 'body');

1341:

1342:

$endpoint = $this->endpointFactory->getEndpoint(UpdateAuditConfiguration::class);

1343:

$endpoint->setParams($params);

1344:

$endpoint->setBody($body);

1345:

1346:

return $this->performRequest($endpoint);

}

/**

* Updates the settings for an existing security configuration. Requires super admin or REST API permissions.

1351:

*

1352:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1353:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1354:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1355:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1356:

* $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 `-`.

1357:

*

1358:

* @param array $params Associative array of parameters

1359:

* @return array

1360:

*/

1361:

public function updateConfiguration(array $params = [])

1362:

{

1363:

$body = $this->extractArgument($params, 'body');

1364:

1365:

$endpoint = $this->endpointFactory->getEndpoint(UpdateConfiguration::class);

1366:

$endpoint->setParams($params);

1367:

$endpoint->setBody($body);

1368:

1369:

return $this->performRequest($endpoint);

}

/**

* Adds or updates the specified distinguished names in the cluster or node allowlist. Requires super admin or REST API permissions.

1374:

*

1375:

* $params['cluster_name'] = (string) The name of the cluster containing the `nodesDn` value to create or update. (Required)

1376:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1377:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1378:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1379:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1380:

* $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 `-`.

1381:

*

1382:

* @param array $params Associative array of parameters

1383:

* @return array

1384:

*/

1385:

public function updateDistinguishedName(array $params = [])

1386:

{

1387:

$cluster_name = $this->extractArgument($params, 'cluster_name');

1388:

$body = $this->extractArgument($params, 'body');

1389:

1390:

$endpoint = $this->endpointFactory->getEndpoint(UpdateDistinguishedName::class);

1391:

$endpoint->setParams($params);

1392:

$endpoint->setClusterName($cluster_name);

1393:

$endpoint->setBody($body);

1394:

1395:

return $this->performRequest($endpoint);

}

/**

* Checks whether the v6 security configuration is valid and ready to be migrated to v7.

1400:

*

1401:

* $params['accept_invalid'] = (boolean) Whether an invalid v6 configuration should be allowed.

1402:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1403:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1404:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1405:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1406:

* $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 `-`.

1407:

*

1408:

* @param array $params Associative array of parameters

1409:

* @return array

1410:

*/

1411:

public function validate(array $params = [])

1412:

{

1413:

$endpoint = $this->endpointFactory->getEndpoint(Validate::class);

1414:

$endpoint->setParams($params);

1415:

1416:

return $this->performRequest($endpoint);

}

/**

* Gets the identity information for the user currently logged in.

1421:

*

1422:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1423:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1424:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1425:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1426:

* $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 `-`.

1427:

*

1428:

* @param array $params Associative array of parameters

1429:

* @return array

1430:

*/

1431:

public function whoAmI(array $params = [])

1432:

{

1433:

$endpoint = $this->endpointFactory->getEndpoint(WhoAmI::class);

1434:

$endpoint->setParams($params);

1435:

1436:

return $this->performRequest($endpoint);

}

/**

* Gets the identity information for the user currently logged in. To use this operation, you must have access to this endpoint when authorization at REST layer is enabled.

1441:

*

1442:

* $params['pretty'] = (boolean) Whether to pretty-format the returned JSON response. (Default = false)

1443:

* $params['human'] = (boolean) Whether to return human-readable values for statistics. (Default = false)

1444:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors. (Default = false)

1445:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1446:

* $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 `-`.

1447:

*

1448:

* @param array $params Associative array of parameters

1449:

* @return array

1450:

*/

1451:

public function whoAmIProtected(array $params = [])

1452:

{

1453:

$endpoint = $this->endpointFactory->getEndpoint(WhoAmIProtected::class);

1454:

$endpoint->setParams($params);

1455:

1456:

return $this->performRequest($endpoint);

}

/**

* Changes the password for the current user.

1461:

*

1462:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1463:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1464:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1465:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1466:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1467:

* $params['current_password'] = (string) The current password

1468:

* $params['password'] = (string) New password

1469:

*

1470:

* @param array $params Associative array of parameters

1471:

* @return array

1472:

*/

1473:

public function changePassword(array $params = [])

1474:

{

1475:

$body = $this->extractArgument($params, 'body');

1476:

if ($body === null) {

1477:

$body = [

1478:

'current_password' => $this->extractArgument($params, 'current_password'),

1479:

'password' => $this->extractArgument($params, 'password'),

];

}

$endpoint = $this->endpointFactory->getEndpoint(ChangePassword::class);

1484:

$endpoint->setParams($params);

1485:

$endpoint->setBody($body);

1486:

1487:

return $this->performRequest($endpoint);

1488:

}

1489:

/**

1490:

* Creates or replaces the specified action group.

1491:

*

1492:

* $params['action_group'] = (string) The name of the action group to create or replace. (Required)

1493:

* $params['allowed_actions'] = (array) list of allowed actions

1494:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1495:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1496:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1497:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1498:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1499:

*

1500:

* @param array $params Associative array of parameters

1501:

* @return array

1502:

*/

1503:

public function createActionGroup(array $params = [])

1504:

{

1505:

$action_group = $this->extractArgument($params, 'action_group');

1506:

$body = $this->extractArgument($params, 'body');

1507:

if ($body === null) {

1508:

$body = [

1509:

'allowed_actions' => $this->extractArgument($params, 'allowed_actions'),

];

}

$endpoint = $this->endpointFactory->getEndpoint(CreateActionGroup::class);

1514:

$endpoint->setParams($params);

1515:

$endpoint->setActionGroup($action_group);

1516:

$endpoint->setBody($body);

1517:

1518:

return $this->performRequest($endpoint);

1519:

}

1520:

/**

1521:

* Creates or replaces the specified role mapping.

1522:

*

1523:

* $params['role'] = (string) (Required)

1524:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1525:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1526:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1527:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1528:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1529:

* $params['backend_roles'] = (array)

1530:

* $params['hosts'] = (array)

1531:

* $params['users'] = (array)

1532:

*

1533:

* @param array $params Associative array of parameters

1534:

* @return array

1535:

*/

1536:

public function createRoleMapping(array $params = [])

1537:

{

1538:

$role = $this->extractArgument($params, 'role');

1539:

$body = $this->extractArgument($params, 'body');

1540:

if ($body === null) {

1541:

$body = array_filter([

1542:

'backend_roles' => $this->extractArgument($params, 'backend_roles'),

1543:

'hosts' => $this->extractArgument($params, 'hosts'),

1544:

'users' => $this->extractArgument($params, 'users'),

]);

}

$endpoint = $this->endpointFactory->getEndpoint(CreateRoleMapping::class);

1549:

$endpoint->setParams($params);

1550:

$endpoint->setRole($role);

1551:

$endpoint->setBody($body);

1552:

1553:

return $this->performRequest($endpoint);

1554:

}

1555:

/**

1556:

* Creates or replaces the specified role.

1557:

*

1558:

* $params['role'] = (string) (Required)

1559:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1560:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1561:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1562:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1563:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1564:

* $params['cluster_permissions'] = (array)

1565:

* $params['index_permissions'] = (array)

1566:

* $params['tenant_permissions'] = (array)

1567:

*

1568:

* @param array $params Associative array of parameters

1569:

* @return array

1570:

*/

1571:

public function createRole(array $params = [])

1572:

{

1573:

$role = $this->extractArgument($params, 'role');

1574:

$body = $this->extractArgument($params, 'body');

1575:

if ($body === null) {

1576:

$body = array_filter([

1577:

'cluster_permissions' => $this->extractArgument($params, 'cluster_permissions'),

1578:

'index_permissions' => $this->extractArgument($params, 'index_permissions'),

1579:

'tenant_permissions' => $this->extractArgument($params, 'tenant_permissions'),

]);

}

$endpoint = $this->endpointFactory->getEndpoint(CreateRole::class);

1584:

$endpoint->setParams($params);

1585:

$endpoint->setRole($role);

1586:

$endpoint->setBody($body);

1587:

1588:

return $this->performRequest($endpoint);

1589:

}

1590:

/**

1591:

* Creates or replaces the specified tenant.

1592:

*

1593:

* $params['tenant'] = (string) The name of the tenant to create

1594:

* $params['description'] = (string) Description of the tenant

1595:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1596:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1597:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1598:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1599:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1600:

*

1601:

* @param array $params Associative array of parameters

1602:

* @return array

1603:

*/

1604:

public function createTenant(array $params = [])

1605:

{

1606:

$tenant = $this->extractArgument($params, 'tenant');

1607:

$body = $this->extractArgument($params, 'body');

1608:

if ($body === null) {

1609:

$body = [

1610:

'description' => $this->extractArgument($params, 'description'),

];

}

$endpoint = $this->endpointFactory->getEndpoint(CreateTenant::class);

1615:

$endpoint->setParams($params);

1616:

$endpoint->setTenant($tenant);

1617:

$endpoint->setBody($body);

1618:

1619:

return $this->performRequest($endpoint);

1620:

}

1621:

/**

1622:

* Creates or replaces the specified user.

1623:

*

1624:

* $params['username'] = (string) (Required)

1625:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1626:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1627:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1628:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1629:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1630:

* $params['password'] = (string)

1631:

* $params['opendistro_security_roles'] = (array)

1632:

* $params['backend_roles'] = (array)

1633:

* $params['attributes'] = (array)

1634:

*

1635:

* @param array $params Associative array of parameters

1636:

* @return array

1637:

*/

1638:

public function createUser(array $params = [])

1639:

{

1640:

$username = $this->extractArgument($params, 'username');

1641:

$body = $this->extractArgument($params, 'body');

1642:

if ($body === null) {

1643:

$body = array_filter([

1644:

'password' => $this->extractArgument($params, 'password'),

1645:

'opendistro_security_roles' => $this->extractArgument($params, 'opendistro_security_roles'),

1646:

'backend_roles' => $this->extractArgument($params, 'backend_roles'),

1647:

'attributes' => $this->extractArgument($params, 'attributes'),

]);

}

$endpoint = $this->endpointFactory->getEndpoint(CreateUser::class);

1652:

$endpoint->setParams($params);

1653:

$endpoint->setUsername($username);

1654:

$endpoint->setBody($body);

1655:

1656:

return $this->performRequest($endpoint);

1657:

}

1658:

/**

1659:

* Proxy function to deleteDistinguishedNames() to prevent BC break.

1660:

* This API will be removed in a future version. Use 'deleteDistinguishedName' API instead.

1661:

*/

1662:

public function deleteDistinguishedNames(array $params = [])

1663:

{

1664:

return $this->deleteDistinguishedName($params);

1665:

}

1666:

/**

1667:

* Proxy function to getAccount() to prevent BC break.

1668:

* This API will be removed in a future version. Use 'getAccountDetails' API instead.

1669:

*/

1670:

public function getAccount(array $params = [])

1671:

{

1672:

return $this->getAccountDetails($params);

1673:

}

1674:

/**

1675:

* Retrieves all action groups.

1676:

* If 'action_group' is provided in $params, calls 'getActionGroup'.

1677:

*

1678:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1679:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1680:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1681:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1682:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1683:

*

1684:

* @param array $params Associative array of parameters

1685:

* @return array

1686:

*/

1687:

public function getActionGroups(array $params = [])

1688:

{

1689:

if (isset($params['action_group'])) {

1690:

$endpoint = $this->endpointFactory->getEndpoint(GetActionGroup::class);

1691:

$action_group = $this->extractArgument($params, 'action_group');

1692:

$endpoint->setActionGroup($action_group);

1693:

} else {

1694:

$endpoint = $this->endpointFactory->getEndpoint(GetActionGroups::class);

1695:

}

1696:

$endpoint->setParams($params);

1697:

1698:

return $this->performRequest($endpoint);

1699:

}

1700:

/**

1701:

* Proxy function to getConfig() to prevent BC break.

1702:

* This API will be removed in a future version. Use 'getConfiguration' API instead.

1703:

*/

1704:

public function getConfig(array $params = [])

1705:

{

1706:

return $this->getConfiguration($params);

1707:

}

1708:

/**

1709:

* Retrieves distinguished names. Only accessible to super-admins and with rest-api permissions when enabled.

1710:

* If 'cluster_name' is provided in $params, calls GetDistinguishedName.

1711:

*

1712:

* $params['cluster_name'] = (string) Name of the cluster.

1713:

* $params['show_all'] = (boolean) Show all DN.

1714:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1715:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1716:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1717:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1718:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1719:

*

1720:

* @param array $params Associative array of parameters

1721:

* @return array

1722:

*/

1723:

public function getDistinguishedNames(array $params = [])

1724:

{

1725:

if (isset($params['cluster_name'])) {

1726:

$endpoint = $this->endpointFactory->getEndpoint(GetDistinguishedName::class);

1727:

$cluster_name = $this->extractArgument($params, 'cluster_name');

1728:

$endpoint->setClusterName($cluster_name);

1729:

} else {

1730:

$endpoint = $this->endpointFactory->getEndpoint(GetDistinguishedNames::class);

1731:

}

1732:

$endpoint->setParams($params);

1733:

1734:

return $this->performRequest($endpoint);

1735:

}

1736:

/**

1737:

* Retrieves role mappings. Only accessible to super-admins and with rest-api permissions when enabled.

1738:

* If 'role' is provided in $params, calls GetRoleMapping.

1739:

*

1740:

* $params['role'] = (string) Name of the role.

1741:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1742:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1743:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1744:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1745:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1746:

*

1747:

* @param array $params Associative array of parameters

1748:

* @return array

1749:

*/

1750:

public function getRoleMappings(array $params = [])

1751:

{

1752:

if (isset($params['role'])) {

1753:

$endpoint = $this->endpointFactory->getEndpoint(GetRoleMapping::class);

1754:

$role = $this->extractArgument($params, 'role');

1755:

$endpoint->setRole($role);

1756:

} else {

1757:

$endpoint = $this->endpointFactory->getEndpoint(GetRoleMappings::class);

1758:

}

1759:

$endpoint->setParams($params);

1760:

1761:

return $this->performRequest($endpoint);

1762:

}

1763:

/**

1764:

* Retrieves roles. Only accessible to super-admins and with rest-api permissions when enabled.

1765:

* If 'role' is provided in $params, calls getRole.

1766:

*

1767:

* $params['role'] = (string) Name of the role.

1768:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1769:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1770:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1771:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1772:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1773:

*

1774:

* @param array $params Associative array of parameters

1775:

* @return array

1776:

*/

1777:

public function getRoles(array $params = [])

1778:

{

1779:

if (isset($params['role'])) {

1780:

$endpoint = $this->endpointFactory->getEndpoint(GetRole::class);

1781:

$role = $this->extractArgument($params, 'role');

1782:

$endpoint->setRole($role);

1783:

} else {

1784:

$endpoint = $this->endpointFactory->getEndpoint(GetRoles::class);

1785:

}

1786:

$endpoint->setParams($params);

1787:

1788:

return $this->performRequest($endpoint);

1789:

}

1790:

/**

1791:

* Retrieves tenants. Only accessible to super-admins and with rest-api permissions when enabled.

1792:

* If 'tenant' is provided in $params, calls GetTenant.

1793:

*

1794:

* $params['tenant'] = (string) Name of the tenant.

1795:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1796:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1797:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1798:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1799:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1800:

*

1801:

* @param array $params Associative array of parameters

1802:

* @return array

1803:

*/

1804:

public function getTenants(array $params = [])

1805:

{

1806:

if (isset($params['tenant'])) {

1807:

$endpoint = $this->endpointFactory->getEndpoint(GetTenant::class);

1808:

$tenant = $this->extractArgument($params, 'tenant');

1809:

$endpoint->setTenant($tenant);

1810:

} else {

1811:

$endpoint = $this->endpointFactory->getEndpoint(GetTenants::class);

1812:

}

1813:

$endpoint->setParams($params);

1814:

1815:

return $this->performRequest($endpoint);

1816:

}

1817:

/**

1818:

* Retrieve all internal users.

1819:

* If 'username' is provided in $params, calls 'getUser'.

1820:

*

1821:

* $params['username'] = (string) The username of the user to fetch, omit to fetch all (optional).

1822:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1823:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1824:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1825:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1826:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1827:

*

1828:

* @param array $params Associative array of parameters

1829:

* @return array

1830:

*/

1831:

public function getUsers(array $params = []): array

1832:

{

1833:

$endpointBuilder = $this->endpoints;

1834:

1835:

if (isset($params['username'])) {

1836:

$endpoint = $this->endpointFactory->getEndpoint(GetUser::class);

1837:

$username = $this->extractArgument($params, 'username');

1838:

$endpoint->setUsername($username);

1839:

} else {

1840:

$endpoint = $this->endpointFactory->getEndpoint(GetUsers::class);

1841:

}

1842:

1843:

$endpoint->setParams($params);

1844:

1845:

return $this->performRequest($endpoint);

1846:

}

1847:

/**

1848:

* Creates, updates, or deletes multiple action groups in a single call.

1849:

* If 'action_group' is provided in $params, calls patchActionGroup.

1850:

*

1851:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1852:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1853:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1854:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1855:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1856:

*

1857:

* @param array $params Associative array of parameters

1858:

* @return array

1859:

*/

1860:

public function patchActionGroups(array $params = [])

1861:

{

1862:

$body = $this->extractArgument($params, 'body');

1863:

1864:

if ($body === null) {

1865:

$body = $this->extractArgument($params, 'ops') ?? [];

1866:

}

1867:

1868:

if (isset($params['action_group'])) {

1869:

$endpoint = $this->endpointFactory->getEndpoint(PatchActionGroup::class);

1870:

$action_group = $this->extractArgument($params, 'action_group');

1871:

$endpoint->setActionGroup($action_group);

1872:

} else {

1873:

$endpoint = $this->endpointFactory->getEndpoint(PatchActionGroups::class);

1874:

}

1875:

$endpoint->setParams($params);

1876:

$endpoint->setBody($body);

1877:

1878:

return $this->performRequest($endpoint);

1879:

}

1880:

/**

1881:

* Proxy function to patchConfig() to prevent BC break.

1882:

* This API will be removed in a future version. Use 'patchConfiguration' API instead.

1883:

*/

1884:

public function patchConfig(array $params = [])

1885:

{

1886:

$ops = $this->extractArgument($params, 'ops');

1887:

if ($ops !== null) {

1888:

$params['body'] = $ops;

1889:

}

1890:

return $this->patchConfiguration($params);

1891:

}

1892:

/**

1893:

* Creates or updates multiple role mappings in a single call.

1894:

* If 'role' is provided in $params, calls patchRoleMappings.

1895:

*

1896:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1897:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1898:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1899:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1900:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1901:

*

1902:

* @param array $params Associative array of parameters

1903:

* @return array

1904:

*/

1905:

public function patchRoleMappings(array $params = [])

1906:

{

1907:

$body = $this->extractArgument($params, 'body');

1908:

if ($body === null) {

1909:

$body = $this->extractArgument($params, 'ops') ?? [];

1910:

}

1911:

1912:

if (isset($params['role'])) {

1913:

$endpoint = $this->endpointFactory->getEndpoint(PatchRoleMapping::class);

1914:

$role = $this->extractArgument($params, 'role');

1915:

$endpoint->setRole($role);

1916:

} else {

1917:

$endpoint = $this->endpointFactory->getEndpoint(PatchRoleMappings::class);

1918:

}

1919:

$endpoint->setParams($params);

1920:

$endpoint->setBody($body);

1921:

1922:

return $this->performRequest($endpoint);

1923:

}

1924:

/**

1925:

* Creates, updates, or deletes multiple roles in a single call.

1926:

* If 'role' is provided in $params, calls patchRole.

1927:

*

1928:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1929:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1930:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1931:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1932:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1933:

*

1934:

* @param array $params Associative array of parameters

1935:

* @return array

1936:

*/

1937:

public function patchRoles(array $params = [])

1938:

{

1939:

$body = $this->extractArgument($params, 'body');

1940:

if ($body === null) {

1941:

$body = $this->extractArgument($params, 'ops') ?? [];

1942:

}

1943:

1944:

if (isset($params['role'])) {

1945:

$endpoint = $this->endpointFactory->getEndpoint(PatchRole::class);

1946:

$role = $this->extractArgument($params, 'role');

1947:

$endpoint->setRole($role);

1948:

} else {

1949:

$endpoint = $this->endpointFactory->getEndpoint(PatchRoles::class);

1950:

}

1951:

1952:

$endpoint->setParams($params);

1953:

$endpoint->setBody($body);

1954:

1955:

return $this->performRequest($endpoint);

1956:

}

1957:

/**

1958:

* Add, delete, or modify multiple tenants in a single call.

1959:

* If 'tenant' is provided in $params, calls 'patchTenant'.

1960:

*

1961:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1962:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1963:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1964:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1965:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1966:

*

1967:

* @param array $params Associative array of parameters

1968:

* @return array

1969:

*/

1970:

public function patchTenants(array $params = [])

1971:

{

1972:

$body = $this->extractArgument($params, 'body');

1973:

if ($body === null) {

1974:

$body = $this->extractArgument($params, 'ops') ?? [];

1975:

}

1976:

1977:

if (isset($params['tenant'])) {

1978:

$endpoint = $this->endpointFactory->getEndpoint(PatchTenant::class);

1979:

$tenant = $this->extractArgument($params, 'tenant');

1980:

$endpoint->setTenant($tenant);

1981:

} else {

1982:

$endpoint = $this->endpointFactory->getEndpoint(PatchTenants::class);

1983:

}

1984:

1985:

$endpoint->setParams($params);

1986:

$endpoint->setBody($body);

1987:

1988:

return $this->performRequest($endpoint);

1989:

}

1990:

/**

1991:

* Creates, updates, or deletes multiple internal users in a single call.

1992:

* If 'username' is provided in $params, calls patchUser.

1993:

*

1994:

* $params['pretty'] = (boolean) Whether to pretty format the returned JSON response.

1995:

* $params['human'] = (boolean) Whether to return human readable values for statistics.

1996:

* $params['error_trace'] = (boolean) Whether to include the stack trace of returned errors.

1997:

* $params['source'] = (string) The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests.

1998:

* $params['filter_path'] = (any) Comma-separated list of filters used to reduce the response.

1999:

*

2000:

* @param array $params Associative array of parameters

2001:

* @return array

2002:

*/

2003:

public function patchUsers(array $params = [])

2004:

{

2005:

$body = $this->extractArgument($params, 'body');

2006:

if ($body === null) {

2007:

$body = $this->extractArgument($params, 'ops') ?? [];

2008:

}

2009:

2010:

if (isset($params['username'])) {

2011:

$endpoint = $this->endpointFactory->getEndpoint(PatchUser::class);

2012:

$username = $this->extractArgument($params, 'username');

2013:

$endpoint->setUsername($username);

2014:

} else {

2015:

$endpoint = $this->endpointFactory->getEndpoint(PatchUsers::class);

2016:

}

2017:

2018:

$endpoint->setParams($params);

2019:

$endpoint->setBody($body);

2020:

2021:

return $this->performRequest($endpoint);

2022:

}

2023:

/**

2024:

* Proxy function to updateConfig() to prevent BC break.

2025:

* This API will be removed in a future version. Use 'updateConfiguration' API instead.

2026:

*/

2027:

public function updateConfig(array $params = [])

2028:

{

2029:

$body = [ 'dynamic' => $this->extractArgument($params, 'dynamic')];

2030:

$params['body'] = $body;

2031:

return $this->updateConfiguration($params);

2032:

}

2033:

/**

2034:

* Proxy function to updateDistinguishedNames() to prevent BC break.

2035:

* This API will be removed in a future version. Use 'updateDistinguishedName' API instead.

2036:

*/

2037:

public function updateDistinguishedNames(array $params = [])

2038:

{

2039:

$body = [ 'nodes_dn' => $this->extractArgument($params, 'nodes_dn')];

2040:

$params['body'] = $body;

2041:

return $this->updateDistinguishedName($params);

2042:

}

2043:

}

2044:

Namespaces

Classes

Interfaces