Source: api/api/security.js

  1. /*
  2.  * Copyright OpenSearch Contributors
  3.  * SPDX-License-Identifier: Apache-2.0
  4.  *
  5.  * The OpenSearch Contributors require contributions made to
  6.  * this file be licensed under the Apache-2.0 license or a
  7.  * compatible open source license.
  8.  *
  9.  */
  11. 'use strict';
  13. /** @namespace API-Security */
  15. /* eslint camelcase: 0 */
  16. /* eslint no-unused-vars: 0 */
  18. const {
  19.   handleError,
  20.   snakeCaseKeys,
  21.   encodePathParam,
  22.   normalizeArguments,
  23.   kConfigurationError,
  24. } = require('../utils');
  25. const snakeCase = {};
  27. function SecurityApi(transport, ConfigurationError) {
  28.   this.transport = transport;
  29.   this[kConfigurationError] = ConfigurationError;
  30. }
  32. /**
  33.  * Changes the password for the current user.
  34.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#change-password - Security - Change Password}
  35.  *
  36.  * @memberOf API-Security
  37.  *
  38.  * @param {Object} params
  39.  * @param {Object} params.body
  40.  *
  41.  * @param {Object} options - Options for {@link Transport#request}
  42.  * @param {function} callback - Callback that handles errors and response
  43.  *
  44.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  45.  */
  46. SecurityApi.prototype.changePassword = function securityChangePasswordApi(
  47.   params,
  48.   options,
  49.   callback
  50. ) {
  51.   [params, options, callback] = normalizeArguments(params, options, callback);
  53.   if (params.body == null) {
  54.     const err = new this[kConfigurationError]('Missing required parameter: body');
  55.     return handleError(err, callback);
  56.   }
  58.   let { method, body, ...querystring } = params;
  60.   let path = ['', '_plugins', '_security', 'api', 'account'].filter((c) => c != null).join('/');
  61.   method = method || 'PUT';
  62.   body = body || '';
  63.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  65.   return this.transport.request({ method, path, body, querystring }, options, callback);
  66. };
  68. /**
  69.  * Creates or replaces the specified action group.
  70.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#create-action-group - Security - Create Action Group}
  71.  *
  72.  * @memberOf API-Security
  73.  *
  74.  * @param {Object} params
  75.  * @param {string} params.action_group - The name of the action group to create or replace
  76.  * @param {Object} params.body
  77.  *
  78.  * @param {Object} options - Options for {@link Transport#request}
  79.  * @param {function} callback - Callback that handles errors and response
  80.  *
  81.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  82.  */
  83. SecurityApi.prototype.createActionGroup = function securityCreateActionGroupApi(
  84.   params,
  85.   options,
  86.   callback
  87. ) {
  88.   [params, options, callback] = normalizeArguments(params, options, callback);
  90.   if (params.actionGroup == null && params.action_group == null) {
  91.     const err = new this[kConfigurationError]('Missing required parameter: action_group');
  92.     return handleError(err, callback);
  93.   }
  94.   if (params.body == null) {
  95.     const err = new this[kConfigurationError]('Missing required parameter: body');
  96.     return handleError(err, callback);
  97.   }
  99.   let { method, body, actionGroup, action_group, ...querystring } = params;
  101.   action_group = encodePathParam(actionGroup, action_group);
  103.   let path = ['', '_plugins', '_security', 'api', 'actiongroups', action_group]
  104.     .filter((c) => c != null)
  105.     .join('/');
  106.   method = method || 'PUT';
  107.   body = body || '';
  108.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  110.   return this.transport.request({ method, path, body, querystring }, options, callback);
  111. };
  113. /**
  114.  * Creates or replaces the specified role.
  115.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#create-role - Security - Create Role}
  116.  *
  117.  * @memberOf API-Security
  118.  *
  119.  * @param {Object} params
  120.  * @param {string} params.role
  121.  * @param {Object} params.body
  122.  *
  123.  * @param {Object} options - Options for {@link Transport#request}
  124.  * @param {function} callback - Callback that handles errors and response
  125.  *
  126.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  127.  */
  128. SecurityApi.prototype.createRole = function securityCreateRoleApi(params, options, callback) {
  129.   [params, options, callback] = normalizeArguments(params, options, callback);
  131.   if (params.role == null) {
  132.     const err = new this[kConfigurationError]('Missing required parameter: role');
  133.     return handleError(err, callback);
  134.   }
  135.   if (params.body == null) {
  136.     const err = new this[kConfigurationError]('Missing required parameter: body');
  137.     return handleError(err, callback);
  138.   }
  140.   let { method, body, role, ...querystring } = params;
  142.   role = encodePathParam(role);
  144.   let path = ['', '_plugins', '_security', 'api', 'roles', role].filter((c) => c != null).join('/');
  145.   method = method || 'PUT';
  146.   body = body || '';
  147.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  149.   return this.transport.request({ method, path, body, querystring }, options, callback);
  150. };
  152. /**
  153.  * Creates or replaces the specified role mapping.
  154.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#create-role-mapping - Security - Create Role Mapping}
  155.  *
  156.  * @memberOf API-Security
  157.  *
  158.  * @param {Object} params
  159.  * @param {string} params.role
  160.  * @param {Object} params.body
  161.  *
  162.  * @param {Object} options - Options for {@link Transport#request}
  163.  * @param {function} callback - Callback that handles errors and response
  164.  *
  165.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  166.  */
  167. SecurityApi.prototype.createRoleMapping = function securityCreateRoleMappingApi(
  168.   params,
  169.   options,
  170.   callback
  171. ) {
  172.   [params, options, callback] = normalizeArguments(params, options, callback);
  174.   if (params.role == null) {
  175.     const err = new this[kConfigurationError]('Missing required parameter: role');
  176.     return handleError(err, callback);
  177.   }
  178.   if (params.body == null) {
  179.     const err = new this[kConfigurationError]('Missing required parameter: body');
  180.     return handleError(err, callback);
  181.   }
  183.   let { method, body, role, ...querystring } = params;
  185.   role = encodePathParam(role);
  187.   let path = ['', '_plugins', '_security', 'api', 'rolesmapping', role]
  188.     .filter((c) => c != null)
  189.     .join('/');
  190.   method = method || 'PUT';
  191.   body = body || '';
  192.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  194.   return this.transport.request({ method, path, body, querystring }, options, callback);
  195. };
  197. /**
  198.  * Creates or replaces the specified tenant.
  199.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#create-tenant - Security - Create Tenant}
  200.  *
  201.  * @memberOf API-Security
  202.  *
  203.  * @param {Object} params
  204.  * @param {string} params.tenant
  205.  * @param {Object} params.body
  206.  *
  207.  * @param {Object} options - Options for {@link Transport#request}
  208.  * @param {function} callback - Callback that handles errors and response
  209.  *
  210.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  211.  */
  212. SecurityApi.prototype.createTenant = function securityCreateTenantApi(params, options, callback) {
  213.   [params, options, callback] = normalizeArguments(params, options, callback);
  215.   if (params.tenant == null) {
  216.     const err = new this[kConfigurationError]('Missing required parameter: tenant');
  217.     return handleError(err, callback);
  218.   }
  219.   if (params.body == null) {
  220.     const err = new this[kConfigurationError]('Missing required parameter: body');
  221.     return handleError(err, callback);
  222.   }
  224.   let { method, body, tenant, ...querystring } = params;
  226.   tenant = encodePathParam(tenant);
  228.   let path = ['', '_plugins', '_security', 'api', 'tenants', tenant]
  229.     .filter((c) => c != null)
  230.     .join('/');
  231.   method = method || 'PUT';
  232.   body = body || '';
  233.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  235.   return this.transport.request({ method, path, body, querystring }, options, callback);
  236. };
  238. /**
  239.  * Creates or replaces the specified user.
  240.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#create-user - Security - Create User}
  241.  *
  242.  * @memberOf API-Security
  243.  *
  244.  * @param {Object} params
  245.  * @param {string} params.username
  246.  * @param {Object} params.body
  247.  *
  248.  * @param {Object} options - Options for {@link Transport#request}
  249.  * @param {function} callback - Callback that handles errors and response
  250.  *
  251.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  252.  */
  253. SecurityApi.prototype.createUser = function securityCreateUserApi(params, options, callback) {
  254.   [params, options, callback] = normalizeArguments(params, options, callback);
  256.   if (params.username == null) {
  257.     const err = new this[kConfigurationError]('Missing required parameter: username');
  258.     return handleError(err, callback);
  259.   }
  260.   if (params.body == null) {
  261.     const err = new this[kConfigurationError]('Missing required parameter: body');
  262.     return handleError(err, callback);
  263.   }
  265.   let { method, body, username, ...querystring } = params;
  267.   username = encodePathParam(username);
  269.   let path = ['', '_plugins', '_security', 'api', 'internalusers', username]
  270.     .filter((c) => c != null)
  271.     .join('/');
  272.   method = method || 'PUT';
  273.   body = body || '';
  274.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  276.   return this.transport.request({ method, path, body, querystring }, options, callback);
  277. };
  279. /**
  280.  * Delete a specified action group.
  281.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#delete-action-group - Security - Delete Action Group}
  282.  *
  283.  * @memberOf API-Security
  284.  *
  285.  * @param {Object} params
  286.  * @param {string} params.action_group - Action group to delete.
  287.  *
  288.  * @param {Object} options - Options for {@link Transport#request}
  289.  * @param {function} callback - Callback that handles errors and response
  290.  *
  291.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  292.  */
  293. SecurityApi.prototype.deleteActionGroup = function securityDeleteActionGroupApi(
  294.   params,
  295.   options,
  296.   callback
  297. ) {
  298.   [params, options, callback] = normalizeArguments(params, options, callback);
  300.   if (params.actionGroup == null && params.action_group == null) {
  301.     const err = new this[kConfigurationError]('Missing required parameter: action_group');
  302.     return handleError(err, callback);
  303.   }
  305.   let { method, body, actionGroup, action_group, ...querystring } = params;
  307.   action_group = encodePathParam(actionGroup, action_group);
  309.   let path = ['', '_plugins', '_security', 'api', 'actiongroups', action_group]
  310.     .filter((c) => c != null)
  311.     .join('/');
  312.   method = method || 'DELETE';
  313.   body = body || '';
  314.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  316.   return this.transport.request({ method, path, body, querystring }, options, callback);
  317. };
  319. /**
  320.  * Deletes all distinguished names in the specified cluster’s or node’s allow list.
  321.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#delete-distinguished-names - Security - Delete Distinguished Names}
  322.  *
  323.  * @memberOf API-Security
  324.  *
  325.  * @param {Object} params
  326.  * @param {string} params.cluster_name
  327.  *
  328.  * @param {Object} options - Options for {@link Transport#request}
  329.  * @param {function} callback - Callback that handles errors and response
  330.  *
  331.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  332.  */
  333. SecurityApi.prototype.deleteDistinguishedNames = function securityDeleteDistinguishedNamesApi(
  334.   params,
  335.   options,
  336.   callback
  337. ) {
  338.   [params, options, callback] = normalizeArguments(params, options, callback);
  340.   if (params.clusterName == null && params.cluster_name == null) {
  341.     const err = new this[kConfigurationError]('Missing required parameter: cluster_name');
  342.     return handleError(err, callback);
  343.   }
  345.   let { method, body, clusterName, cluster_name, ...querystring } = params;
  347.   cluster_name = encodePathParam(clusterName, cluster_name);
  349.   let path = ['', '_plugins', '_security', 'api', 'nodesdn', cluster_name]
  350.     .filter((c) => c != null)
  351.     .join('/');
  352.   method = method || 'DELETE';
  353.   body = body || '';
  354.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  356.   return this.transport.request({ method, path, body, querystring }, options, callback);
  357. };
  359. /**
  360.  * Delete the specified role.
  361.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#delete-role - Security - Delete Role}
  362.  *
  363.  * @memberOf API-Security
  364.  *
  365.  * @param {Object} params
  366.  * @param {string} params.role
  367.  *
  368.  * @param {Object} options - Options for {@link Transport#request}
  369.  * @param {function} callback - Callback that handles errors and response
  370.  *
  371.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  372.  */
  373. SecurityApi.prototype.deleteRole = function securityDeleteRoleApi(params, options, callback) {
  374.   [params, options, callback] = normalizeArguments(params, options, callback);
  376.   if (params.role == null) {
  377.     const err = new this[kConfigurationError]('Missing required parameter: role');
  378.     return handleError(err, callback);
  379.   }
  381.   let { method, body, role, ...querystring } = params;
  383.   role = encodePathParam(role);
  385.   let path = ['', '_plugins', '_security', 'api', 'roles', role].filter((c) => c != null).join('/');
  386.   method = method || 'DELETE';
  387.   body = body || '';
  388.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  390.   return this.transport.request({ method, path, body, querystring }, options, callback);
  391. };
  393. /**
  394.  * Deletes the specified role mapping.
  395.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#delete-role-mapping - Security - Delete Role Mapping}
  396.  *
  397.  * @memberOf API-Security
  398.  *
  399.  * @param {Object} params
  400.  * @param {string} params.role
  401.  *
  402.  * @param {Object} options - Options for {@link Transport#request}
  403.  * @param {function} callback - Callback that handles errors and response
  404.  *
  405.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  406.  */
  407. SecurityApi.prototype.deleteRoleMapping = function securityDeleteRoleMappingApi(
  408.   params,
  409.   options,
  410.   callback
  411. ) {
  412.   [params, options, callback] = normalizeArguments(params, options, callback);
  414.   if (params.role == null) {
  415.     const err = new this[kConfigurationError]('Missing required parameter: role');
  416.     return handleError(err, callback);
  417.   }
  419.   let { method, body, role, ...querystring } = params;
  421.   role = encodePathParam(role);
  423.   let path = ['', '_plugins', '_security', 'api', 'rolesmapping', role]
  424.     .filter((c) => c != null)
  425.     .join('/');
  426.   method = method || 'DELETE';
  427.   body = body || '';
  428.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  430.   return this.transport.request({ method, path, body, querystring }, options, callback);
  431. };
  433. /**
  434.  * Delete the specified tenant.
  435.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#delete-action-group - Security - Delete Tenant}
  436.  *
  437.  * @memberOf API-Security
  438.  *
  439.  * @param {Object} params
  440.  * @param {string} params.tenant
  441.  *
  442.  * @param {Object} options - Options for {@link Transport#request}
  443.  * @param {function} callback - Callback that handles errors and response
  444.  *
  445.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  446.  */
  447. SecurityApi.prototype.deleteTenant = function securityDeleteTenantApi(params, options, callback) {
  448.   [params, options, callback] = normalizeArguments(params, options, callback);
  450.   if (params.tenant == null) {
  451.     const err = new this[kConfigurationError]('Missing required parameter: tenant');
  452.     return handleError(err, callback);
  453.   }
  455.   let { method, body, tenant, ...querystring } = params;
  457.   tenant = encodePathParam(tenant);
  459.   let path = ['', '_plugins', '_security', 'api', 'tenants', tenant]
  460.     .filter((c) => c != null)
  461.     .join('/');
  462.   method = method || 'DELETE';
  463.   body = body || '';
  464.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  466.   return this.transport.request({ method, path, body, querystring }, options, callback);
  467. };
  469. /**
  470.  * Delete the specified user.
  471.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#delete-user - Security - Delete User}
  472.  *
  473.  * @memberOf API-Security
  474.  *
  475.  * @param {Object} params
  476.  * @param {string} params.username
  477.  *
  478.  * @param {Object} options - Options for {@link Transport#request}
  479.  * @param {function} callback - Callback that handles errors and response
  480.  *
  481.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  482.  */
  483. SecurityApi.prototype.deleteUser = function securityDeleteUserApi(params, options, callback) {
  484.   [params, options, callback] = normalizeArguments(params, options, callback);
  486.   if (params.username == null) {
  487.     const err = new this[kConfigurationError]('Missing required parameter: username');
  488.     return handleError(err, callback);
  489.   }
  491.   let { method, body, username, ...querystring } = params;
  493.   username = encodePathParam(username);
  495.   let path = ['', '_plugins', '_security', 'api', 'internalusers', username]
  496.     .filter((c) => c != null)
  497.     .join('/');
  498.   method = method || 'DELETE';
  499.   body = body || '';
  500.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  502.   return this.transport.request({ method, path, body, querystring }, options, callback);
  503. };
  505. /**
  506.  * Flushes the Security plugin user, authentication, and authorization cache.
  507.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#flush-cache - Security - Flush Cache}
  508.  *
  509.  * @memberOf API-Security
  510.  *
  511.  * @param {Object} params
  512.  *
  513.  * @param {Object} options - Options for {@link Transport#request}
  514.  * @param {function} callback - Callback that handles errors and response
  515.  *
  516.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  517.  */
  518. SecurityApi.prototype.flushCache = function securityFlushCacheApi(params, options, callback) {
  519.   [params, options, callback] = normalizeArguments(params, options, callback);
  521.   let { method, body, ...querystring } = params;
  523.   let path = ['', '_plugins', '_security', 'api', 'cache'].filter((c) => c != null).join('/');
  524.   method = method || 'DELETE';
  525.   body = body || '';
  526.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  528.   return this.transport.request({ method, path, body, querystring }, options, callback);
  529. };
  531. /**
  532.  * Returns account details for the current user.
  533.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-account-details - Security - Get Account Details}
  534.  *
  535.  * @memberOf API-Security
  536.  *
  537.  * @param {Object} params
  538.  *
  539.  * @param {Object} options - Options for {@link Transport#request}
  540.  * @param {function} callback - Callback that handles errors and response
  541.  *
  542.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  543.  */
  544. SecurityApi.prototype.getAccountDetails = function securityGetAccountDetailsApi(
  545.   params,
  546.   options,
  547.   callback
  548. ) {
  549.   [params, options, callback] = normalizeArguments(params, options, callback);
  551.   let { method, body, ...querystring } = params;
  553.   let path = ['', '_plugins', '_security', 'api', 'account'].filter((c) => c != null).join('/');
  554.   method = method || 'GET';
  555.   body = body || '';
  556.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  558.   return this.transport.request({ method, path, body, querystring }, options, callback);
  559. };
  561. /**
  562.  * Retrieves one action group.
  563.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-action-group - Security - Get Action Group}
  564.  *
  565.  * @memberOf API-Security
  566.  *
  567.  * @param {Object} params
  568.  * @param {string} params.action_group - Action group to retrieve.
  569.  *
  570.  * @param {Object} options - Options for {@link Transport#request}
  571.  * @param {function} callback - Callback that handles errors and response
  572.  *
  573.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  574.  */
  575. SecurityApi.prototype.getActionGroup = function securityGetActionGroupApi(
  576.   params,
  577.   options,
  578.   callback
  579. ) {
  580.   [params, options, callback] = normalizeArguments(params, options, callback);
  582.   if (params.actionGroup == null && params.action_group == null) {
  583.     const err = new this[kConfigurationError]('Missing required parameter: action_group');
  584.     return handleError(err, callback);
  585.   }
  587.   let { method, body, actionGroup, action_group, ...querystring } = params;
  589.   action_group = encodePathParam(actionGroup, action_group);
  591.   let path = ['', '_plugins', '_security', 'api', 'actiongroups', action_group]
  592.     .filter((c) => c != null)
  593.     .join('/');
  594.   method = method || 'GET';
  595.   body = body || '';
  596.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  598.   return this.transport.request({ method, path, body, querystring }, options, callback);
  599. };
  601. /**
  602.  * Retrieves all action groups.
  603.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-action-groups - Security - Get Action Groups}
  604.  *
  605.  * @memberOf API-Security
  606.  *
  607.  * @param {Object} params
  608.  *
  609.  * @param {Object} options - Options for {@link Transport#request}
  610.  * @param {function} callback - Callback that handles errors and response
  611.  *
  612.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  613.  */
  614. SecurityApi.prototype.getActionGroups = function securityGetActionGroupsApi(
  615.   params,
  616.   options,
  617.   callback
  618. ) {
  619.   [params, options, callback] = normalizeArguments(params, options, callback);
  621.   let { method, body, ...querystring } = params;
  623.   let path = ['', '_plugins', '_security', 'api', 'actiongroups']
  624.     .filter((c) => c != null)
  625.     .join('/');
  626.   method = method || 'GET';
  627.   body = body || '';
  628.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  630.   return this.transport.request({ method, path, body, querystring }, options, callback);
  631. };
  633. /**
  634.  * Retrieves the audit configuration.
  635.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#audit-logs - Security - Get Audit Configuration}
  636.  *
  637.  * @memberOf API-Security
  638.  *
  639.  * @param {Object} params
  640.  *
  641.  * @param {Object} options - Options for {@link Transport#request}
  642.  * @param {function} callback - Callback that handles errors and response
  643.  *
  644.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  645.  */
  646. SecurityApi.prototype.getAuditConfiguration = function securityGetAuditConfigurationApi(
  647.   params,
  648.   options,
  649.   callback
  650. ) {
  651.   [params, options, callback] = normalizeArguments(params, options, callback);
  653.   let { method, body, ...querystring } = params;
  655.   let path = ['', '_plugins', '_security', 'api', 'audit'].filter((c) => c != null).join('/');
  656.   method = method || 'GET';
  657.   body = body || '';
  658.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  660.   return this.transport.request({ method, path, body, querystring }, options, callback);
  661. };
  663. /**
  664.  * Retrieves the cluster’s security certificates.
  665.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-certificates - Security - Get Certificates}
  666.  *
  667.  * @memberOf API-Security
  668.  *
  669.  * @param {Object} params
  670.  *
  671.  * @param {Object} options - Options for {@link Transport#request}
  672.  * @param {function} callback - Callback that handles errors and response
  673.  *
  674.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  675.  */
  676. SecurityApi.prototype.getCertificates = function securityGetCertificatesApi(
  677.   params,
  678.   options,
  679.   callback
  680. ) {
  681.   [params, options, callback] = normalizeArguments(params, options, callback);
  683.   let { method, body, ...querystring } = params;
  685.   let path = ['', '_plugins', '_security', 'api', 'ssl', 'certs']
  686.     .filter((c) => c != null)
  687.     .join('/');
  688.   method = method || 'GET';
  689.   body = body || '';
  690.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  692.   return this.transport.request({ method, path, body, querystring }, options, callback);
  693. };
  695. /**
  696.  * Returns the current Security plugin configuration in JSON format.
  697.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#get-configuration - Security - Get Configuration}
  698.  *
  699.  * @memberOf API-Security
  700.  *
  701.  * @param {Object} params
  702.  *
  703.  * @param {Object} options - Options for {@link Transport#request}
  704.  * @param {function} callback - Callback that handles errors and response
  705.  *
  706.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  707.  */
  708. SecurityApi.prototype.getConfiguration = function securityGetConfigurationApi(
  709.   params,
  710.   options,
  711.   callback
  712. ) {
  713.   [params, options, callback] = normalizeArguments(params, options, callback);
  715.   let { method, body, ...querystring } = params;
  717.   let path = ['', '_plugins', '_security', 'api', 'securityconfig']
  718.     .filter((c) => c != null)
  719.     .join('/');
  720.   method = method || 'GET';
  721.   body = body || '';
  722.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  724.   return this.transport.request({ method, path, body, querystring }, options, callback);
  725. };
  727. /**
  728.  * Retrieves all distinguished names in the allow list.
  729.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-distinguished-names - Security - Get Distinguished Names}
  730.  *
  731.  * @memberOf API-Security
  732.  *
  733.  * @param {Object} params
  734.  * @param {string} [params.cluster_name]
  735.  *
  736.  * @param {Object} options - Options for {@link Transport#request}
  737.  * @param {function} callback - Callback that handles errors and response
  738.  *
  739.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  740.  */
  741. SecurityApi.prototype.getDistinguishedNames = function securityGetDistinguishedNamesApi(
  742.   params,
  743.   options,
  744.   callback
  745. ) {
  746.   [params, options, callback] = normalizeArguments(params, options, callback);
  748.   let { method, body, clusterName, cluster_name, ...querystring } = params;
  750.   cluster_name = encodePathParam(clusterName, cluster_name);
  752.   let path = ['', '_plugins', '_security', 'api', 'nodesdn', cluster_name]
  753.     .filter((c) => c != null)
  754.     .join('/');
  755.   method = method || 'GET';
  756.   body = body || '';
  757.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  759.   return this.transport.request({ method, path, body, querystring }, options, callback);
  760. };
  762. /**
  763.  * Retrieves one role.
  764.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-role - Security - Get Role}
  765.  *
  766.  * @memberOf API-Security
  767.  *
  768.  * @param {Object} params
  769.  * @param {string} params.role
  770.  *
  771.  * @param {Object} options - Options for {@link Transport#request}
  772.  * @param {function} callback - Callback that handles errors and response
  773.  *
  774.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  775.  */
  776. SecurityApi.prototype.getRole = function securityGetRoleApi(params, options, callback) {
  777.   [params, options, callback] = normalizeArguments(params, options, callback);
  779.   if (params.role == null) {
  780.     const err = new this[kConfigurationError]('Missing required parameter: role');
  781.     return handleError(err, callback);
  782.   }
  784.   let { method, body, role, ...querystring } = params;
  786.   role = encodePathParam(role);
  788.   let path = ['', '_plugins', '_security', 'api', 'roles', role].filter((c) => c != null).join('/');
  789.   method = method || 'GET';
  790.   body = body || '';
  791.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  793.   return this.transport.request({ method, path, body, querystring }, options, callback);
  794. };
  796. /**
  797.  * Retrieves one role mapping.
  798.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-role-mapping - Security - Get Role Mapping}
  799.  *
  800.  * @memberOf API-Security
  801.  *
  802.  * @param {Object} params
  803.  * @param {string} params.role
  804.  *
  805.  * @param {Object} options - Options for {@link Transport#request}
  806.  * @param {function} callback - Callback that handles errors and response
  807.  *
  808.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  809.  */
  810. SecurityApi.prototype.getRoleMapping = function securityGetRoleMappingApi(
  811.   params,
  812.   options,
  813.   callback
  814. ) {
  815.   [params, options, callback] = normalizeArguments(params, options, callback);
  817.   if (params.role == null) {
  818.     const err = new this[kConfigurationError]('Missing required parameter: role');
  819.     return handleError(err, callback);
  820.   }
  822.   let { method, body, role, ...querystring } = params;
  824.   role = encodePathParam(role);
  826.   let path = ['', '_plugins', '_security', 'api', 'rolesmapping', role]
  827.     .filter((c) => c != null)
  828.     .join('/');
  829.   method = method || 'GET';
  830.   body = body || '';
  831.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  833.   return this.transport.request({ method, path, body, querystring }, options, callback);
  834. };
  836. /**
  837.  * Retrieves all role mappings.
  838.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-role-mappings - Security - Get Role Mappings}
  839.  *
  840.  * @memberOf API-Security
  841.  *
  842.  * @param {Object} params
  843.  *
  844.  * @param {Object} options - Options for {@link Transport#request}
  845.  * @param {function} callback - Callback that handles errors and response
  846.  *
  847.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  848.  */
  849. SecurityApi.prototype.getRoleMappings = function securityGetRoleMappingsApi(
  850.   params,
  851.   options,
  852.   callback
  853. ) {
  854.   [params, options, callback] = normalizeArguments(params, options, callback);
  856.   let { method, body, ...querystring } = params;
  858.   let path = ['', '_plugins', '_security', 'api', 'rolesmapping']
  859.     .filter((c) => c != null)
  860.     .join('/');
  861.   method = method || 'GET';
  862.   body = body || '';
  863.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  865.   return this.transport.request({ method, path, body, querystring }, options, callback);
  866. };
  868. /**
  869.  * Retrieves all roles.
  870.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-roles - Security - Get Roles}
  871.  *
  872.  * @memberOf API-Security
  873.  *
  874.  * @param {Object} params
  875.  *
  876.  * @param {Object} options - Options for {@link Transport#request}
  877.  * @param {function} callback - Callback that handles errors and response
  878.  *
  879.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  880.  */
  881. SecurityApi.prototype.getRoles = function securityGetRolesApi(params, options, callback) {
  882.   [params, options, callback] = normalizeArguments(params, options, callback);
  884.   let { method, body, ...querystring } = params;
  886.   let path = ['', '_plugins', '_security', 'api', 'roles'].filter((c) => c != null).join('/');
  887.   method = method || 'GET';
  888.   body = body || '';
  889.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  891.   return this.transport.request({ method, path, body, querystring }, options, callback);
  892. };
  894. /**
  895.  * Retrieves one tenant.
  896.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#get-tenant - Security - Get Tenant}
  897.  *
  898.  * @memberOf API-Security
  899.  *
  900.  * @param {Object} params
  901.  * @param {string} params.tenant
  902.  *
  903.  * @param {Object} options - Options for {@link Transport#request}
  904.  * @param {function} callback - Callback that handles errors and response
  905.  *
  906.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  907.  */
  908. SecurityApi.prototype.getTenant = function securityGetTenantApi(params, options, callback) {
  909.   [params, options, callback] = normalizeArguments(params, options, callback);
  911.   if (params.tenant == null) {
  912.     const err = new this[kConfigurationError]('Missing required parameter: tenant');
  913.     return handleError(err, callback);
  914.   }
  916.   let { method, body, tenant, ...querystring } = params;
  918.   tenant = encodePathParam(tenant);
  920.   let path = ['', '_plugins', '_security', 'api', 'tenants', tenant]
  921.     .filter((c) => c != null)
  922.     .join('/');
  923.   method = method || 'GET';
  924.   body = body || '';
  925.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  927.   return this.transport.request({ method, path, body, querystring }, options, callback);
  928. };
  930. /**
  931.  * Retrieves all tenants.
  932.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#get-tenants - Security - Get Tenants}
  933.  *
  934.  * @memberOf API-Security
  935.  *
  936.  * @param {Object} params
  937.  *
  938.  * @param {Object} options - Options for {@link Transport#request}
  939.  * @param {function} callback - Callback that handles errors and response
  940.  *
  941.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  942.  */
  943. SecurityApi.prototype.getTenants = function securityGetTenantsApi(params, options, callback) {
  944.   [params, options, callback] = normalizeArguments(params, options, callback);
  946.   let { method, body, ...querystring } = params;
  948.   let path = ['', '_plugins', '_security', 'api', 'tenants'].filter((c) => c != null).join('/');
  949.   method = method || 'GET';
  950.   body = body || '';
  951.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  953.   return this.transport.request({ method, path, body, querystring }, options, callback);
  954. };
  956. /**
  957.  * Retrieve one internal user.
  958.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-user - Security - Get User}
  959.  *
  960.  * @memberOf API-Security
  961.  *
  962.  * @param {Object} params
  963.  * @param {string} params.username
  964.  *
  965.  * @param {Object} options - Options for {@link Transport#request}
  966.  * @param {function} callback - Callback that handles errors and response
  967.  *
  968.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  969.  */
  970. SecurityApi.prototype.getUser = function securityGetUserApi(params, options, callback) {
  971.   [params, options, callback] = normalizeArguments(params, options, callback);
  973.   if (params.username == null) {
  974.     const err = new this[kConfigurationError]('Missing required parameter: username');
  975.     return handleError(err, callback);
  976.   }
  978.   let { method, body, username, ...querystring } = params;
  980.   username = encodePathParam(username);
  982.   let path = ['', '_plugins', '_security', 'api', 'internalusers', username]
  983.     .filter((c) => c != null)
  984.     .join('/');
  985.   method = method || 'GET';
  986.   body = body || '';
  987.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  989.   return this.transport.request({ method, path, body, querystring }, options, callback);
  990. };
  992. /**
  993.  * Retrieve all internal users.
  994.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#get-users - Security - Get Users}
  995.  *
  996.  * @memberOf API-Security
  997.  *
  998.  * @param {Object} params
  999.  *
  1000.  * @param {Object} options - Options for {@link Transport#request}
  1001.  * @param {function} callback - Callback that handles errors and response
  1002.  *
  1003.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1004.  */
  1005. SecurityApi.prototype.getUsers = function securityGetUsersApi(params, options, callback) {
  1006.   [params, options, callback] = normalizeArguments(params, options, callback);
  1008.   let { method, body, ...querystring } = params;
  1010.   let path = ['', '_plugins', '_security', 'api', 'internalusers']
  1011.     .filter((c) => c != null)
  1012.     .join('/');
  1013.   method = method || 'GET';
  1014.   body = body || '';
  1015.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1017.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1018. };
  1020. /**
  1021.  * Checks to see if the Security plugin is up and running.
  1022.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#health-check - Security - Health}
  1023.  *
  1024.  * @memberOf API-Security
  1025.  *
  1026.  * @param {Object} params
  1027.  *
  1028.  * @param {Object} options - Options for {@link Transport#request}
  1029.  * @param {function} callback - Callback that handles errors and response
  1030.  *
  1031.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1032.  */
  1033. SecurityApi.prototype.health = function securityHealthApi(params, options, callback) {
  1034.   [params, options, callback] = normalizeArguments(params, options, callback);
  1036.   let { method, body, ...querystring } = params;
  1038.   let path = ['', '_plugins', '_security', 'health'].filter((c) => c != null).join('/');
  1039.   method = method || 'GET';
  1040.   body = body || '';
  1041.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1043.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1044. };
  1046. /**
  1047.  * Updates individual attributes of an action group.
  1048.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-action-group - Security - Patch Action Group}
  1049.  *
  1050.  * @memberOf API-Security
  1051.  *
  1052.  * @param {Object} params
  1053.  * @param {string} params.action_group
  1054.  * @param {Object} params.body
  1055.  *
  1056.  * @param {Object} options - Options for {@link Transport#request}
  1057.  * @param {function} callback - Callback that handles errors and response
  1058.  *
  1059.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1060.  */
  1061. SecurityApi.prototype.patchActionGroup = function securityPatchActionGroupApi(
  1062.   params,
  1063.   options,
  1064.   callback
  1065. ) {
  1066.   [params, options, callback] = normalizeArguments(params, options, callback);
  1068.   if (params.actionGroup == null && params.action_group == null) {
  1069.     const err = new this[kConfigurationError]('Missing required parameter: action_group');
  1070.     return handleError(err, callback);
  1071.   }
  1072.   if (params.body == null) {
  1073.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1074.     return handleError(err, callback);
  1075.   }
  1077.   let { method, body, actionGroup, action_group, ...querystring } = params;
  1079.   action_group = encodePathParam(actionGroup, action_group);
  1081.   let path = ['', '_plugins', '_security', 'api', 'actiongroups', action_group]
  1082.     .filter((c) => c != null)
  1083.     .join('/');
  1084.   method = method || 'PATCH';
  1085.   body = body || '';
  1086.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1088.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1089. };
  1091. /**
  1092.  * Creates, updates, or deletes multiple action groups in a single call.
  1093.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-action-groups - Security - Patch Action Groups}
  1094.  *
  1095.  * @memberOf API-Security
  1096.  *
  1097.  * @param {Object} params
  1098.  * @param {Object} params.body
  1099.  *
  1100.  * @param {Object} options - Options for {@link Transport#request}
  1101.  * @param {function} callback - Callback that handles errors and response
  1102.  *
  1103.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1104.  */
  1105. SecurityApi.prototype.patchActionGroups = function securityPatchActionGroupsApi(
  1106.   params,
  1107.   options,
  1108.   callback
  1109. ) {
  1110.   [params, options, callback] = normalizeArguments(params, options, callback);
  1112.   if (params.body == null) {
  1113.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1114.     return handleError(err, callback);
  1115.   }
  1117.   let { method, body, ...querystring } = params;
  1119.   let path = ['', '_plugins', '_security', 'api', 'actiongroups']
  1120.     .filter((c) => c != null)
  1121.     .join('/');
  1122.   method = method || 'PATCH';
  1123.   body = body || '';
  1124.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1126.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1127. };
  1129. /**
  1130.  * A PATCH call is used to update specified fields in the audit configuration.
  1131.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#audit-logs - Security - Patch Audit Configuration}
  1132.  *
  1133.  * @memberOf API-Security
  1134.  *
  1135.  * @param {Object} params
  1136.  * @param {Object} params.body
  1137.  *
  1138.  * @param {Object} options - Options for {@link Transport#request}
  1139.  * @param {function} callback - Callback that handles errors and response
  1140.  *
  1141.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1142.  */
  1143. SecurityApi.prototype.patchAuditConfiguration = function securityPatchAuditConfigurationApi(
  1144.   params,
  1145.   options,
  1146.   callback
  1147. ) {
  1148.   [params, options, callback] = normalizeArguments(params, options, callback);
  1150.   if (params.body == null) {
  1151.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1152.     return handleError(err, callback);
  1153.   }
  1155.   let { method, body, ...querystring } = params;
  1157.   let path = ['', '_plugins', '_security', 'api', 'audit'].filter((c) => c != null).join('/');
  1158.   method = method || 'PATCH';
  1159.   body = body || '';
  1160.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1162.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1163. };
  1165. /**
  1166.  * A PATCH call is used to update the existing configuration using the REST API.
  1167.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#patch-configuration - Security - Patch Configuration}
  1168.  *
  1169.  * @memberOf API-Security
  1170.  *
  1171.  * @param {Object} params
  1172.  * @param {Object} params.body
  1173.  *
  1174.  * @param {Object} options - Options for {@link Transport#request}
  1175.  * @param {function} callback - Callback that handles errors and response
  1176.  *
  1177.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1178.  */
  1179. SecurityApi.prototype.patchConfiguration = function securityPatchConfigurationApi(
  1180.   params,
  1181.   options,
  1182.   callback
  1183. ) {
  1184.   [params, options, callback] = normalizeArguments(params, options, callback);
  1186.   if (params.body == null) {
  1187.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1188.     return handleError(err, callback);
  1189.   }
  1191.   let { method, body, ...querystring } = params;
  1193.   let path = ['', '_plugins', '_security', 'api', 'securityconfig']
  1194.     .filter((c) => c != null)
  1195.     .join('/');
  1196.   method = method || 'PATCH';
  1197.   body = body || '';
  1198.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1200.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1201. };
  1203. /**
  1204.  * Bulk update of distinguished names.
  1205.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#update-all-distinguished-names - Security - Patch Distinguished Names}
  1206.  *
  1207.  * @memberOf API-Security
  1208.  *
  1209.  * @param {Object} params
  1210.  * @param {Object} params.body
  1211.  *
  1212.  * @param {Object} options - Options for {@link Transport#request}
  1213.  * @param {function} callback - Callback that handles errors and response
  1214.  *
  1215.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1216.  */
  1217. SecurityApi.prototype.patchDistinguishedNames = function securityPatchDistinguishedNamesApi(
  1218.   params,
  1219.   options,
  1220.   callback
  1221. ) {
  1222.   [params, options, callback] = normalizeArguments(params, options, callback);
  1224.   if (params.body == null) {
  1225.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1226.     return handleError(err, callback);
  1227.   }
  1229.   let { method, body, ...querystring } = params;
  1231.   let path = ['', '_plugins', '_security', 'api', 'nodesdn'].filter((c) => c != null).join('/');
  1232.   method = method || 'PATCH';
  1233.   body = body || '';
  1234.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1236.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1237. };
  1239. /**
  1240.  * Updates individual attributes of a role.
  1241.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-role - Security - Patch Role}
  1242.  *
  1243.  * @memberOf API-Security
  1244.  *
  1245.  * @param {Object} params
  1246.  * @param {string} params.role
  1247.  * @param {Object} params.body
  1248.  *
  1249.  * @param {Object} options - Options for {@link Transport#request}
  1250.  * @param {function} callback - Callback that handles errors and response
  1251.  *
  1252.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1253.  */
  1254. SecurityApi.prototype.patchRole = function securityPatchRoleApi(params, options, callback) {
  1255.   [params, options, callback] = normalizeArguments(params, options, callback);
  1257.   if (params.role == null) {
  1258.     const err = new this[kConfigurationError]('Missing required parameter: role');
  1259.     return handleError(err, callback);
  1260.   }
  1261.   if (params.body == null) {
  1262.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1263.     return handleError(err, callback);
  1264.   }
  1266.   let { method, body, role, ...querystring } = params;
  1268.   role = encodePathParam(role);
  1270.   let path = ['', '_plugins', '_security', 'api', 'roles', role].filter((c) => c != null).join('/');
  1271.   method = method || 'PATCH';
  1272.   body = body || '';
  1273.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1275.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1276. };
  1278. /**
  1279.  * Updates individual attributes of a role mapping.
  1280.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-role-mapping - Security - Patch Role Mapping}
  1281.  *
  1282.  * @memberOf API-Security
  1283.  *
  1284.  * @param {Object} params
  1285.  * @param {string} params.role
  1286.  * @param {Object} params.body
  1287.  *
  1288.  * @param {Object} options - Options for {@link Transport#request}
  1289.  * @param {function} callback - Callback that handles errors and response
  1290.  *
  1291.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1292.  */
  1293. SecurityApi.prototype.patchRoleMapping = function securityPatchRoleMappingApi(
  1294.   params,
  1295.   options,
  1296.   callback
  1297. ) {
  1298.   [params, options, callback] = normalizeArguments(params, options, callback);
  1300.   if (params.role == null) {
  1301.     const err = new this[kConfigurationError]('Missing required parameter: role');
  1302.     return handleError(err, callback);
  1303.   }
  1304.   if (params.body == null) {
  1305.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1306.     return handleError(err, callback);
  1307.   }
  1309.   let { method, body, role, ...querystring } = params;
  1311.   role = encodePathParam(role);
  1313.   let path = ['', '_plugins', '_security', 'api', 'rolesmapping', role]
  1314.     .filter((c) => c != null)
  1315.     .join('/');
  1316.   method = method || 'PATCH';
  1317.   body = body || '';
  1318.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1320.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1321. };
  1323. /**
  1324.  * Creates or updates multiple role mappings in a single call.
  1325.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-role-mappings - Security - Patch Role Mappings}
  1326.  *
  1327.  * @memberOf API-Security
  1328.  *
  1329.  * @param {Object} params
  1330.  * @param {Object} params.body
  1331.  *
  1332.  * @param {Object} options - Options for {@link Transport#request}
  1333.  * @param {function} callback - Callback that handles errors and response
  1334.  *
  1335.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1336.  */
  1337. SecurityApi.prototype.patchRoleMappings = function securityPatchRoleMappingsApi(
  1338.   params,
  1339.   options,
  1340.   callback
  1341. ) {
  1342.   [params, options, callback] = normalizeArguments(params, options, callback);
  1344.   if (params.body == null) {
  1345.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1346.     return handleError(err, callback);
  1347.   }
  1349.   let { method, body, ...querystring } = params;
  1351.   let path = ['', '_plugins', '_security', 'api', 'rolesmapping']
  1352.     .filter((c) => c != null)
  1353.     .join('/');
  1354.   method = method || 'PATCH';
  1355.   body = body || '';
  1356.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1358.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1359. };
  1361. /**
  1362.  * Creates, updates, or deletes multiple roles in a single call.
  1363.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-roles - Security - Patch Roles}
  1364.  *
  1365.  * @memberOf API-Security
  1366.  *
  1367.  * @param {Object} params
  1368.  * @param {Object} params.body
  1369.  *
  1370.  * @param {Object} options - Options for {@link Transport#request}
  1371.  * @param {function} callback - Callback that handles errors and response
  1372.  *
  1373.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1374.  */
  1375. SecurityApi.prototype.patchRoles = function securityPatchRolesApi(params, options, callback) {
  1376.   [params, options, callback] = normalizeArguments(params, options, callback);
  1378.   if (params.body == null) {
  1379.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1380.     return handleError(err, callback);
  1381.   }
  1383.   let { method, body, ...querystring } = params;
  1385.   let path = ['', '_plugins', '_security', 'api', 'roles'].filter((c) => c != null).join('/');
  1386.   method = method || 'PATCH';
  1387.   body = body || '';
  1388.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1390.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1391. };
  1393. /**
  1394.  * Add, delete, or modify a single tenant.
  1395.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#patch-tenant - Security - Patch Tenant}
  1396.  *
  1397.  * @memberOf API-Security
  1398.  *
  1399.  * @param {Object} params
  1400.  * @param {string} params.tenant
  1401.  * @param {Object} params.body
  1402.  *
  1403.  * @param {Object} options - Options for {@link Transport#request}
  1404.  * @param {function} callback - Callback that handles errors and response
  1405.  *
  1406.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1407.  */
  1408. SecurityApi.prototype.patchTenant = function securityPatchTenantApi(params, options, callback) {
  1409.   [params, options, callback] = normalizeArguments(params, options, callback);
  1411.   if (params.tenant == null) {
  1412.     const err = new this[kConfigurationError]('Missing required parameter: tenant');
  1413.     return handleError(err, callback);
  1414.   }
  1415.   if (params.body == null) {
  1416.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1417.     return handleError(err, callback);
  1418.   }
  1420.   let { method, body, tenant, ...querystring } = params;
  1422.   tenant = encodePathParam(tenant);
  1424.   let path = ['', '_plugins', '_security', 'api', 'tenants', tenant]
  1425.     .filter((c) => c != null)
  1426.     .join('/');
  1427.   method = method || 'PATCH';
  1428.   body = body || '';
  1429.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1431.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1432. };
  1434. /**
  1435.  * Add, delete, or modify multiple tenants in a single call.
  1436.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#patch-tenants - Security - Patch Tenants}
  1437.  *
  1438.  * @memberOf API-Security
  1439.  *
  1440.  * @param {Object} params
  1441.  * @param {Object} params.body
  1442.  *
  1443.  * @param {Object} options - Options for {@link Transport#request}
  1444.  * @param {function} callback - Callback that handles errors and response
  1445.  *
  1446.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1447.  */
  1448. SecurityApi.prototype.patchTenants = function securityPatchTenantsApi(params, options, callback) {
  1449.   [params, options, callback] = normalizeArguments(params, options, callback);
  1451.   if (params.body == null) {
  1452.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1453.     return handleError(err, callback);
  1454.   }
  1456.   let { method, body, ...querystring } = params;
  1458.   let path = ['', '_plugins', '_security', 'api', 'tenants'].filter((c) => c != null).join('/');
  1459.   method = method || 'PATCH';
  1460.   body = body || '';
  1461.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1463.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1464. };
  1466. /**
  1467.  * Updates individual attributes of an internal user.
  1468.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-user - Security - Patch User}
  1469.  *
  1470.  * @memberOf API-Security
  1471.  *
  1472.  * @param {Object} params
  1473.  * @param {string} params.username
  1474.  * @param {Object} params.body
  1475.  *
  1476.  * @param {Object} options - Options for {@link Transport#request}
  1477.  * @param {function} callback - Callback that handles errors and response
  1478.  *
  1479.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1480.  */
  1481. SecurityApi.prototype.patchUser = function securityPatchUserApi(params, options, callback) {
  1482.   [params, options, callback] = normalizeArguments(params, options, callback);
  1484.   if (params.username == null) {
  1485.     const err = new this[kConfigurationError]('Missing required parameter: username');
  1486.     return handleError(err, callback);
  1487.   }
  1488.   if (params.body == null) {
  1489.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1490.     return handleError(err, callback);
  1491.   }
  1493.   let { method, body, username, ...querystring } = params;
  1495.   username = encodePathParam(username);
  1497.   let path = ['', '_plugins', '_security', 'api', 'internalusers', username]
  1498.     .filter((c) => c != null)
  1499.     .join('/');
  1500.   method = method || 'PATCH';
  1501.   body = body || '';
  1502.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1504.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1505. };
  1507. /**
  1508.  * Creates, updates, or deletes multiple internal users in a single call.
  1509.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#patch-users - Security - Patch Users}
  1510.  *
  1511.  * @memberOf API-Security
  1512.  *
  1513.  * @param {Object} params
  1514.  * @param {Object} params.body
  1515.  *
  1516.  * @param {Object} options - Options for {@link Transport#request}
  1517.  * @param {function} callback - Callback that handles errors and response
  1518.  *
  1519.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1520.  */
  1521. SecurityApi.prototype.patchUsers = function securityPatchUsersApi(params, options, callback) {
  1522.   [params, options, callback] = normalizeArguments(params, options, callback);
  1524.   if (params.body == null) {
  1525.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1526.     return handleError(err, callback);
  1527.   }
  1529.   let { method, body, ...querystring } = params;
  1531.   let path = ['', '_plugins', '_security', 'api', 'internalusers']
  1532.     .filter((c) => c != null)
  1533.     .join('/');
  1534.   method = method || 'PATCH';
  1535.   body = body || '';
  1536.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1538.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1539. };
  1541. /**
  1542.  * Reload HTTP layer communication certificates.
  1543.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#reload-http-certificates - Security - Reload Http Certificates}
  1544.  *
  1545.  * @memberOf API-Security
  1546.  *
  1547.  * @param {Object} params
  1548.  *
  1549.  * @param {Object} options - Options for {@link Transport#request}
  1550.  * @param {function} callback - Callback that handles errors and response
  1551.  *
  1552.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1553.  */
  1554. SecurityApi.prototype.reloadHttpCertificates = function securityReloadHttpCertificatesApi(
  1555.   params,
  1556.   options,
  1557.   callback
  1558. ) {
  1559.   [params, options, callback] = normalizeArguments(params, options, callback);
  1561.   let { method, body, ...querystring } = params;
  1563.   let path = ['', '_plugins', '_security', 'api', 'ssl', 'http', 'reloadcerts']
  1564.     .filter((c) => c != null)
  1565.     .join('/');
  1566.   method = method || 'PUT';
  1567.   body = body || '';
  1568.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1570.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1571. };
  1573. /**
  1574.  * Reload transport layer communication certificates.
  1575.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#reload-transport-certificates - Security - Reload Transport Certificates}
  1576.  *
  1577.  * @memberOf API-Security
  1578.  *
  1579.  * @param {Object} params
  1580.  *
  1581.  * @param {Object} options - Options for {@link Transport#request}
  1582.  * @param {function} callback - Callback that handles errors and response
  1583.  *
  1584.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1585.  */
  1586. SecurityApi.prototype.reloadTransportCertificates = function securityReloadTransportCertificatesApi(
  1587.   params,
  1588.   options,
  1589.   callback
  1590. ) {
  1591.   [params, options, callback] = normalizeArguments(params, options, callback);
  1593.   let { method, body, ...querystring } = params;
  1595.   let path = ['', '_plugins', '_security', 'api', 'ssl', 'transport', 'reloadcerts']
  1596.     .filter((c) => c != null)
  1597.     .join('/');
  1598.   method = method || 'PUT';
  1599.   body = body || '';
  1600.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1602.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1603. };
  1605. /**
  1606.  * Updates the audit configuration.
  1607.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#audit-logs - Security - Update Audit Configuration}
  1608.  *
  1609.  * @memberOf API-Security
  1610.  *
  1611.  * @param {Object} params
  1612.  * @param {Object} params.body
  1613.  *
  1614.  * @param {Object} options - Options for {@link Transport#request}
  1615.  * @param {function} callback - Callback that handles errors and response
  1616.  *
  1617.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1618.  */
  1619. SecurityApi.prototype.updateAuditConfiguration = function securityUpdateAuditConfigurationApi(
  1620.   params,
  1621.   options,
  1622.   callback
  1623. ) {
  1624.   [params, options, callback] = normalizeArguments(params, options, callback);
  1626.   if (params.body == null) {
  1627.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1628.     return handleError(err, callback);
  1629.   }
  1631.   let { method, body, ...querystring } = params;
  1633.   let path = ['', '_plugins', '_security', 'api', 'audit', 'config']
  1634.     .filter((c) => c != null)
  1635.     .join('/');
  1636.   method = method || 'PUT';
  1637.   body = body || '';
  1638.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1640.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1641. };
  1643. /**
  1644.  * Adds or updates the existing configuration using the REST API.
  1645.  * <br/> See Also: {@link https://opensearch.org/docs/2.7/security/access-control/api/#update-configuration - Security - Update Configuration}
  1646.  *
  1647.  * @memberOf API-Security
  1648.  *
  1649.  * @param {Object} params
  1650.  * @param {Object} params.body
  1651.  *
  1652.  * @param {Object} options - Options for {@link Transport#request}
  1653.  * @param {function} callback - Callback that handles errors and response
  1654.  *
  1655.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1656.  */
  1657. SecurityApi.prototype.updateConfiguration = function securityUpdateConfigurationApi(
  1658.   params,
  1659.   options,
  1660.   callback
  1661. ) {
  1662.   [params, options, callback] = normalizeArguments(params, options, callback);
  1664.   if (params.body == null) {
  1665.     const err = new this[kConfigurationError]('Missing required parameter: body');
  1666.     return handleError(err, callback);
  1667.   }
  1669.   let { method, body, ...querystring } = params;
  1671.   let path = ['', '_plugins', '_security', 'api', 'securityconfig', 'config']
  1672.     .filter((c) => c != null)
  1673.     .join('/');
  1674.   method = method || 'PUT';
  1675.   body = body || '';
  1676.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1678.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1679. };
  1681. /**
  1682.  * Adds or updates the specified distinguished names in the cluster’s or node’s allow list.
  1683.  * <br/> See Also: {@link https://opensearch.org/docs/latest/security/access-control/api/#update-distinguished-names - Security - Update Distinguished Names}
  1684.  *
  1685.  * @memberOf API-Security
  1686.  *
  1687.  * @param {Object} params
  1688.  * @param {string} params.cluster_name
  1689.  * @param {Object} [params.body]
  1690.  *
  1691.  * @param {Object} options - Options for {@link Transport#request}
  1692.  * @param {function} callback - Callback that handles errors and response
  1693.  *
  1694.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  1695.  */
  1696. SecurityApi.prototype.updateDistinguishedNames = function securityUpdateDistinguishedNamesApi(
  1697.   params,
  1698.   options,
  1699.   callback
  1700. ) {
  1701.   [params, options, callback] = normalizeArguments(params, options, callback);
  1703.   if (params.clusterName == null && params.cluster_name == null) {
  1704.     const err = new this[kConfigurationError]('Missing required parameter: cluster_name');
  1705.     return handleError(err, callback);
  1706.   }
  1708.   let { method, body, clusterName, cluster_name, ...querystring } = params;
  1710.   cluster_name = encodePathParam(clusterName, cluster_name);
  1712.   let path = ['', '_plugins', '_security', 'api', 'nodesdn', cluster_name]
  1713.     .filter((c) => c != null)
  1714.     .join('/');
  1715.   method = method || 'PUT';
  1716.   body = body || '';
  1717.   querystring = snakeCaseKeys(null, snakeCase, querystring);
  1719.   return this.transport.request({ method, path, body, querystring }, options, callback);
  1720. };
  1722. Object.defineProperties(SecurityApi.prototype, {
  1723.   change_password: {
  1724.     get() {
  1725.       return this.changePassword;
  1726.     },
  1727.   },
  1728.   create_action_group: {
  1729.     get() {
  1730.       return this.createActionGroup;
  1731.     },
  1732.   },
  1733.   create_role: {
  1734.     get() {
  1735.       return this.createRole;
  1736.     },
  1737.   },
  1738.   create_role_mapping: {
  1739.     get() {
  1740.       return this.createRoleMapping;
  1741.     },
  1742.   },
  1743.   create_tenant: {
  1744.     get() {
  1745.       return this.createTenant;
  1746.     },
  1747.   },
  1748.   create_user: {
  1749.     get() {
  1750.       return this.createUser;
  1751.     },
  1752.   },
  1753.   delete_action_group: {
  1754.     get() {
  1755.       return this.deleteActionGroup;
  1756.     },
  1757.   },
  1758.   delete_distinguished_names: {
  1759.     get() {
  1760.       return this.deleteDistinguishedNames;
  1761.     },
  1762.   },
  1763.   delete_role: {
  1764.     get() {
  1765.       return this.deleteRole;
  1766.     },
  1767.   },
  1768.   delete_role_mapping: {
  1769.     get() {
  1770.       return this.deleteRoleMapping;
  1771.     },
  1772.   },
  1773.   delete_tenant: {
  1774.     get() {
  1775.       return this.deleteTenant;
  1776.     },
  1777.   },
  1778.   delete_user: {
  1779.     get() {
  1780.       return this.deleteUser;
  1781.     },
  1782.   },
  1783.   flush_cache: {
  1784.     get() {
  1785.       return this.flushCache;
  1786.     },
  1787.   },
  1788.   get_account_details: {
  1789.     get() {
  1790.       return this.getAccountDetails;
  1791.     },
  1792.   },
  1793.   get_action_group: {
  1794.     get() {
  1795.       return this.getActionGroup;
  1796.     },
  1797.   },
  1798.   get_action_groups: {
  1799.     get() {
  1800.       return this.getActionGroups;
  1801.     },
  1802.   },
  1803.   get_audit_configuration: {
  1804.     get() {
  1805.       return this.getAuditConfiguration;
  1806.     },
  1807.   },
  1808.   get_certificates: {
  1809.     get() {
  1810.       return this.getCertificates;
  1811.     },
  1812.   },
  1813.   get_configuration: {
  1814.     get() {
  1815.       return this.getConfiguration;
  1816.     },
  1817.   },
  1818.   get_distinguished_names: {
  1819.     get() {
  1820.       return this.getDistinguishedNames;
  1821.     },
  1822.   },
  1823.   get_role: {
  1824.     get() {
  1825.       return this.getRole;
  1826.     },
  1827.   },
  1828.   get_role_mapping: {
  1829.     get() {
  1830.       return this.getRoleMapping;
  1831.     },
  1832.   },
  1833.   get_role_mappings: {
  1834.     get() {
  1835.       return this.getRoleMappings;
  1836.     },
  1837.   },
  1838.   get_roles: {
  1839.     get() {
  1840.       return this.getRoles;
  1841.     },
  1842.   },
  1843.   get_tenant: {
  1844.     get() {
  1845.       return this.getTenant;
  1846.     },
  1847.   },
  1848.   get_tenants: {
  1849.     get() {
  1850.       return this.getTenants;
  1851.     },
  1852.   },
  1853.   get_user: {
  1854.     get() {
  1855.       return this.getUser;
  1856.     },
  1857.   },
  1858.   get_users: {
  1859.     get() {
  1860.       return this.getUsers;
  1861.     },
  1862.   },
  1863.   patch_action_group: {
  1864.     get() {
  1865.       return this.patchActionGroup;
  1866.     },
  1867.   },
  1868.   patch_action_groups: {
  1869.     get() {
  1870.       return this.patchActionGroups;
  1871.     },
  1872.   },
  1873.   patch_audit_configuration: {
  1874.     get() {
  1875.       return this.patchAuditConfiguration;
  1876.     },
  1877.   },
  1878.   patch_configuration: {
  1879.     get() {
  1880.       return this.patchConfiguration;
  1881.     },
  1882.   },
  1883.   patch_distinguished_names: {
  1884.     get() {
  1885.       return this.patchDistinguishedNames;
  1886.     },
  1887.   },
  1888.   patch_role: {
  1889.     get() {
  1890.       return this.patchRole;
  1891.     },
  1892.   },
  1893.   patch_role_mapping: {
  1894.     get() {
  1895.       return this.patchRoleMapping;
  1896.     },
  1897.   },
  1898.   patch_role_mappings: {
  1899.     get() {
  1900.       return this.patchRoleMappings;
  1901.     },
  1902.   },
  1903.   patch_roles: {
  1904.     get() {
  1905.       return this.patchRoles;
  1906.     },
  1907.   },
  1908.   patch_tenant: {
  1909.     get() {
  1910.       return this.patchTenant;
  1911.     },
  1912.   },
  1913.   patch_tenants: {
  1914.     get() {
  1915.       return this.patchTenants;
  1916.     },
  1917.   },
  1918.   patch_user: {
  1919.     get() {
  1920.       return this.patchUser;
  1921.     },
  1922.   },
  1923.   patch_users: {
  1924.     get() {
  1925.       return this.patchUsers;
  1926.     },
  1927.   },
  1928.   reload_http_certificates: {
  1929.     get() {
  1930.       return this.reloadHttpCertificates;
  1931.     },
  1932.   },
  1933.   reload_transport_certificates: {
  1934.     get() {
  1935.       return this.reloadTransportCertificates;
  1936.     },
  1937.   },
  1938.   update_audit_configuration: {
  1939.     get() {
  1940.       return this.updateAuditConfiguration;
  1941.     },
  1942.   },
  1943.   update_configuration: {
  1944.     get() {
  1945.       return this.updateConfiguration;
  1946.     },
  1947.   },
  1948.   update_distinguished_names: {
  1949.     get() {
  1950.       return this.updateDistinguishedNames;
  1951.     },
  1952.   },
  1953. });
  1954. module.exports = SecurityApi;