Package com.cyberark.conjur.sdk.endpoint

Class AuthenticationApi

java.lang.Object
com.cyberark.conjur.sdk.endpoint.AuthenticationApi
public class AuthenticationApi extends Object

  • Constructor Details

    • AuthenticationApi

      public AuthenticationApi()

    • AuthenticationApi

      public AuthenticationApi(ApiClient apiClient)

  • Method Details

    • getApiClient

      public ApiClient getApiClient()

    • setApiClient

      public void setApiClient(ApiClient apiClient)

    • changePasswordCall

      public okhttp3.Call changePasswordCall(String account, String body, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for changePassword
      Parameters:
      account - Organization account name (required)
      body - New password (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      204 The password has been changed -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • changePassword

      public void changePassword(String account, String body, String xRequestId) throws ApiException
      Changes a user’s password. You must provide the login name and current password or API key of the user whose password is to be updated in an HTTP Basic Authentication header. Also replaces the user’s API key with a new securely generated random value. You can fetch the new API key using the Login method. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords. They authenticate using their API keys, while passwords are only used by human users.
      Parameters:
      account - Organization account name (required)
      body - New password (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The password has been changed -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • changePassword

      public void changePassword(String account, String body) throws ApiException
      Changes a user’s password. You must provide the login name and current password or API key of the user whose password is to be updated in an HTTP Basic Authentication header. Also replaces the user’s API key with a new securely generated random value. You can fetch the new API key using the Login method. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords. They authenticate using their API keys, while passwords are only used by human users.
      Parameters:
      account - Organization account name
      body - New password
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The password has been changed -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • changePasswordWithHttpInfo

      public ApiResponse<Void> changePasswordWithHttpInfo(String account, String body, String xRequestId) throws ApiException
      Changes a user’s password. You must provide the login name and current password or API key of the user whose password is to be updated in an HTTP Basic Authentication header. Also replaces the user’s API key with a new securely generated random value. You can fetch the new API key using the Login method. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords. They authenticate using their API keys, while passwords are only used by human users.
      Parameters:
      account - Organization account name (required)
      body - New password (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The password has been changed -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • changePasswordWithHttpInfo

      public ApiResponse<Void> changePasswordWithHttpInfo(String account, String body) throws ApiException
      Changes a user’s password. You must provide the login name and current password or API key of the user whose password is to be updated in an HTTP Basic Authentication header. Also replaces the user’s API key with a new securely generated random value. You can fetch the new API key using the Login method. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords. They authenticate using their API keys, while passwords are only used by human users.
      Parameters:
      account - Organization account name
      body - New password
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The password has been changed -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • changePasswordAsync

      public okhttp3.Call changePasswordAsync(String account, String body, String xRequestId, ApiCallback<Void> _callback) throws ApiException
      Changes a user’s password. (asynchronously) You must provide the login name and current password or API key of the user whose password is to be updated in an HTTP Basic Authentication header. Also replaces the user’s API key with a new securely generated random value. You can fetch the new API key using the Login method. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords. They authenticate using their API keys, while passwords are only used by human users.
      Parameters:
      account - Organization account name (required)
      body - New password (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      204 The password has been changed -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorCall

      public okhttp3.Call enableAuthenticatorCall(ServiceAuthenticators authenticator, String account, String xRequestId, Boolean enabled, ApiCallback _callback) throws ApiException
      Build call for enableAuthenticator
      Parameters:
      authenticator - The authenticator to update (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticator

      public void enableAuthenticator(ServiceAuthenticators authenticator, String account, String xRequestId, Boolean enabled) throws ApiException
      Enables or disables authenticator defined without service_id. Allows you to either enable or disable a given authenticator that does not have service_id (For example: authn-gcp). When you enable or disable an authenticator via this endpoint, the status of the authenticator is stored in the Conjur database. The enablement status of the authenticator service may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticator

      public void enableAuthenticator(ServiceAuthenticators authenticator, String account) throws ApiException
      Enables or disables authenticator defined without service_id. Allows you to either enable or disable a given authenticator that does not have service_id (For example: authn-gcp). When you enable or disable an authenticator via this endpoint, the status of the authenticator is stored in the Conjur database. The enablement status of the authenticator service may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update
      account - Organization account name
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorWithHttpInfo

      public ApiResponse<Void> enableAuthenticatorWithHttpInfo(ServiceAuthenticators authenticator, String account, String xRequestId, Boolean enabled) throws ApiException
      Enables or disables authenticator defined without service_id. Allows you to either enable or disable a given authenticator that does not have service_id (For example: authn-gcp). When you enable or disable an authenticator via this endpoint, the status of the authenticator is stored in the Conjur database. The enablement status of the authenticator service may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorWithHttpInfo

      public ApiResponse<Void> enableAuthenticatorWithHttpInfo(ServiceAuthenticators authenticator, String account) throws ApiException
      Enables or disables authenticator defined without service_id. Allows you to either enable or disable a given authenticator that does not have service_id (For example: authn-gcp). When you enable or disable an authenticator via this endpoint, the status of the authenticator is stored in the Conjur database. The enablement status of the authenticator service may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update
      account - Organization account name
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorAsync

      public okhttp3.Call enableAuthenticatorAsync(ServiceAuthenticators authenticator, String account, String xRequestId, Boolean enabled, ApiCallback<Void> _callback) throws ApiException
      Enables or disables authenticator defined without service_id. (asynchronously) Allows you to either enable or disable a given authenticator that does not have service_id (For example: authn-gcp). When you enable or disable an authenticator via this endpoint, the status of the authenticator is stored in the Conjur database. The enablement status of the authenticator service may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorInstanceCall

      public okhttp3.Call enableAuthenticatorInstanceCall(ServiceAuthenticators authenticator, String serviceId, String account, String xRequestId, Boolean enabled, ApiCallback _callback) throws ApiException
      Build call for enableAuthenticatorInstance
      Parameters:
      authenticator - The authenticator to update (required)
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorInstance

      public void enableAuthenticatorInstance(ServiceAuthenticators authenticator, String serviceId, String account, String xRequestId, Boolean enabled) throws ApiException
      Enables or disables authenticator service instances. Allows you to either enable or disable a given authenticator service instance. When you enable or disable an authenticator service instance via this endpoint, the status of the authenticator service instance is stored in the Conjur database. The enablement status of the authenticator service instance may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service instance is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update (required)
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorInstance

      public void enableAuthenticatorInstance(ServiceAuthenticators authenticator, String serviceId, String account) throws ApiException
      Enables or disables authenticator service instances. Allows you to either enable or disable a given authenticator service instance. When you enable or disable an authenticator service instance via this endpoint, the status of the authenticator service instance is stored in the Conjur database. The enablement status of the authenticator service instance may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service instance is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorInstanceWithHttpInfo

      public ApiResponse<Void> enableAuthenticatorInstanceWithHttpInfo(ServiceAuthenticators authenticator, String serviceId, String account, String xRequestId, Boolean enabled) throws ApiException
      Enables or disables authenticator service instances. Allows you to either enable or disable a given authenticator service instance. When you enable or disable an authenticator service instance via this endpoint, the status of the authenticator service instance is stored in the Conjur database. The enablement status of the authenticator service instance may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service instance is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update (required)
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorInstanceWithHttpInfo

      public ApiResponse<Void> enableAuthenticatorInstanceWithHttpInfo(ServiceAuthenticators authenticator, String serviceId, String account) throws ApiException
      Enables or disables authenticator service instances. Allows you to either enable or disable a given authenticator service instance. When you enable or disable an authenticator service instance via this endpoint, the status of the authenticator service instance is stored in the Conjur database. The enablement status of the authenticator service instance may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service instance is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • enableAuthenticatorInstanceAsync

      public okhttp3.Call enableAuthenticatorInstanceAsync(ServiceAuthenticators authenticator, String serviceId, String account, String xRequestId, Boolean enabled, ApiCallback<Void> _callback) throws ApiException
      Enables or disables authenticator service instances. (asynchronously) Allows you to either enable or disable a given authenticator service instance. When you enable or disable an authenticator service instance via this endpoint, the status of the authenticator service instance is stored in the Conjur database. The enablement status of the authenticator service instance may be overridden by setting the `CONJUR_AUTHENTICATORS` environment variable on the Conjur server; in the case where this environment variable is set, the database record of whether the authenticator service instance is enabled will be ignored. **This endpoint is part of an early implementation of support for enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This endpoint is still subject to breaking changes in the future.**
      Parameters:
      authenticator - The authenticator to update (required)
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      enabled - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      204 The config was updated properly -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAPIKeyCall

      public okhttp3.Call getAPIKeyCall(String account, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for getAPIKey
      Parameters:
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKey

      public String getAPIKey(String account, String xRequestId) throws ApiException
      Gets the API key of a user given the username and password via HTTP Basic Authentication. Passwords are stored in the Conjur database using `bcrypt` with a work factor of 12. Therefore, login is a fairly expensive operation. However, once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords and do not need to use this endpoint.
      Parameters:
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKey

      public String getAPIKey(String account) throws ApiException
      Gets the API key of a user given the username and password via HTTP Basic Authentication. Passwords are stored in the Conjur database using `bcrypt` with a work factor of 12. Therefore, login is a fairly expensive operation. However, once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords and do not need to use this endpoint.
      Parameters:
      account - Organization account name
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyWithHttpInfo

      public ApiResponse<String> getAPIKeyWithHttpInfo(String account, String xRequestId) throws ApiException
      Gets the API key of a user given the username and password via HTTP Basic Authentication. Passwords are stored in the Conjur database using `bcrypt` with a work factor of 12. Therefore, login is a fairly expensive operation. However, once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords and do not need to use this endpoint.
      Parameters:
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyWithHttpInfo

      public ApiResponse<String> getAPIKeyWithHttpInfo(String account) throws ApiException
      Gets the API key of a user given the username and password via HTTP Basic Authentication. Passwords are stored in the Conjur database using `bcrypt` with a work factor of 12. Therefore, login is a fairly expensive operation. However, once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords and do not need to use this endpoint.
      Parameters:
      account - Organization account name
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyAsync

      public okhttp3.Call getAPIKeyAsync(String account, String xRequestId, ApiCallback<String> _callback) throws ApiException
      Gets the API key of a user given the username and password via HTTP Basic Authentication. (asynchronously) Passwords are stored in the Conjur database using `bcrypt` with a work factor of 12. Therefore, login is a fairly expensive operation. However, once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. Note that machine roles (Hosts) do not have passwords and do not need to use this endpoint.
      Parameters:
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyViaLDAPCall

      public okhttp3.Call getAPIKeyViaLDAPCall(String serviceId, String account, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for getAPIKeyViaLDAP
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyViaLDAP

      public String getAPIKeyViaLDAP(String serviceId, String account, String xRequestId) throws ApiException
      Gets the Conjur API key of a user given the LDAP username and password via HTTP Basic Authentication. Exchange your LDAP credentials for a Conjur API key. Once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the LDAP username, a literal colon character ':', and the password to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support.
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyViaLDAP

      public String getAPIKeyViaLDAP(String serviceId, String account) throws ApiException
      Gets the Conjur API key of a user given the LDAP username and password via HTTP Basic Authentication. Exchange your LDAP credentials for a Conjur API key. Once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the LDAP username, a literal colon character ':', and the password to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support.
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyViaLDAPWithHttpInfo

      public ApiResponse<String> getAPIKeyViaLDAPWithHttpInfo(String serviceId, String account, String xRequestId) throws ApiException
      Gets the Conjur API key of a user given the LDAP username and password via HTTP Basic Authentication. Exchange your LDAP credentials for a Conjur API key. Once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the LDAP username, a literal colon character ':', and the password to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support.
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyViaLDAPWithHttpInfo

      public ApiResponse<String> getAPIKeyViaLDAPWithHttpInfo(String serviceId, String account) throws ApiException
      Gets the Conjur API key of a user given the LDAP username and password via HTTP Basic Authentication. Exchange your LDAP credentials for a Conjur API key. Once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the LDAP username, a literal colon character ':', and the password to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support.
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAPIKeyViaLDAPAsync

      public okhttp3.Call getAPIKeyViaLDAPAsync(String serviceId, String account, String xRequestId, ApiCallback<String> _callback) throws ApiException
      Gets the Conjur API key of a user given the LDAP username and password via HTTP Basic Authentication. (asynchronously) Exchange your LDAP credentials for a Conjur API key. Once the API key is obtained, it may be used to inexpensively obtain access tokens by calling the Authenticate method. An access token is required to use most other parts of the Conjur API. The Basic authentication-compliant header is formed by: 1. Concatenating the LDAP username, a literal colon character ':', and the password to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support.
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • getAccessTokenCall

      public okhttp3.Call getAccessTokenCall(String account, String login, String body, String acceptEncoding, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for getAccessToken
      Parameters:
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      body - API Key (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessToken

      public String getAccessToken(String account, String login, String body, String acceptEncoding, String xRequestId) throws ApiException
      Gets a short-lived access token, which is required in the header of most subsequent API requests. A client can obtain an access token by presenting a valid login name and API key. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. This is the default authentication endpoint only. See other endpoints for details on authenticating to Conjur using another method, e.g. for applications running in Azure or Kubernetes.
      Parameters:
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      body - API Key (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessToken

      public String getAccessToken(String account, String login, String body) throws ApiException
      Gets a short-lived access token, which is required in the header of most subsequent API requests. A client can obtain an access token by presenting a valid login name and API key. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. This is the default authentication endpoint only. See other endpoints for details on authenticating to Conjur using another method, e.g. for applications running in Azure or Kubernetes.
      Parameters:
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      body - API Key
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenWithHttpInfo

      public ApiResponse<String> getAccessTokenWithHttpInfo(String account, String login, String body, String acceptEncoding, String xRequestId) throws ApiException
      Gets a short-lived access token, which is required in the header of most subsequent API requests. A client can obtain an access token by presenting a valid login name and API key. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. This is the default authentication endpoint only. See other endpoints for details on authenticating to Conjur using another method, e.g. for applications running in Azure or Kubernetes.
      Parameters:
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      body - API Key (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenWithHttpInfo

      public ApiResponse<String> getAccessTokenWithHttpInfo(String account, String login, String body) throws ApiException
      Gets a short-lived access token, which is required in the header of most subsequent API requests. A client can obtain an access token by presenting a valid login name and API key. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. This is the default authentication endpoint only. See other endpoints for details on authenticating to Conjur using another method, e.g. for applications running in Azure or Kubernetes.
      Parameters:
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      body - API Key
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenAsync

      public okhttp3.Call getAccessTokenAsync(String account, String login, String body, String acceptEncoding, String xRequestId, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token, which is required in the header of most subsequent API requests. (asynchronously) A client can obtain an access token by presenting a valid login name and API key. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. This is the default authentication endpoint only. See other endpoints for details on authenticating to Conjur using another method, e.g. for applications running in Azure or Kubernetes.
      Parameters:
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      body - API Key (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAWSCall

      public okhttp3.Call getAccessTokenViaAWSCall(String serviceId, String account, String login, String body, String acceptEncoding, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaAWS
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For hosts, the login name is `host/<host-id>` (required)
      body - AWS Signature header (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAWS

      public String getAccessTokenViaAWS(String serviceId, String account, String login, String body, String acceptEncoding, String xRequestId) throws ApiException
      Get a short-lived access token for applications running in AWS. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For detailed instructions on authenticating to Conjur using this endpoint, reference the documentation: [AWS IAM Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/AWS_IAM_Authenticator.htm) (`authn-iam`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For hosts, the login name is `host/<host-id>` (required)
      body - AWS Signature header (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAWS

      public String getAccessTokenViaAWS(String serviceId, String account, String login, String body) throws ApiException
      Get a short-lived access token for applications running in AWS. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For detailed instructions on authenticating to Conjur using this endpoint, reference the documentation: [AWS IAM Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/AWS_IAM_Authenticator.htm) (`authn-iam`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For hosts, the login name is `host/<host-id>`
      body - AWS Signature header
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAWSWithHttpInfo

      public ApiResponse<String> getAccessTokenViaAWSWithHttpInfo(String serviceId, String account, String login, String body, String acceptEncoding, String xRequestId) throws ApiException
      Get a short-lived access token for applications running in AWS. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For detailed instructions on authenticating to Conjur using this endpoint, reference the documentation: [AWS IAM Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/AWS_IAM_Authenticator.htm) (`authn-iam`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For hosts, the login name is `host/<host-id>` (required)
      body - AWS Signature header (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAWSWithHttpInfo

      public ApiResponse<String> getAccessTokenViaAWSWithHttpInfo(String serviceId, String account, String login, String body) throws ApiException
      Get a short-lived access token for applications running in AWS. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For detailed instructions on authenticating to Conjur using this endpoint, reference the documentation: [AWS IAM Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/AWS_IAM_Authenticator.htm) (`authn-iam`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For hosts, the login name is `host/<host-id>`
      body - AWS Signature header
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAWSAsync

      public okhttp3.Call getAccessTokenViaAWSAsync(String serviceId, String account, String login, String body, String acceptEncoding, String xRequestId, ApiCallback<String> _callback) throws ApiException
      Get a short-lived access token for applications running in AWS. (asynchronously) The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For detailed instructions on authenticating to Conjur using this endpoint, reference the documentation: [AWS IAM Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/AWS_IAM_Authenticator.htm) (`authn-iam`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For hosts, the login name is `host/<host-id>` (required)
      body - AWS Signature header (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAzureCall

      public okhttp3.Call getAccessTokenViaAzureCall(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String jwt, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaAzure
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAzure

      public String getAccessTokenViaAzure(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications running in Azure. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Azure Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/azure_authn.htm) (`authn-azure`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAzure

      public String getAccessTokenViaAzure(String serviceId, String account, String login) throws ApiException
      Gets a short-lived access token for applications running in Azure. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Azure Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/azure_authn.htm) (`authn-azure`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAzureWithHttpInfo

      public ApiResponse<String> getAccessTokenViaAzureWithHttpInfo(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications running in Azure. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Azure Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/azure_authn.htm) (`authn-azure`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAzureWithHttpInfo

      public ApiResponse<String> getAccessTokenViaAzureWithHttpInfo(String serviceId, String account, String login) throws ApiException
      Gets a short-lived access token for applications running in Azure. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Azure Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/azure_authn.htm) (`authn-azure`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaAzureAsync

      public okhttp3.Call getAccessTokenViaAzureAsync(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String jwt, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token for applications running in Azure. (asynchronously) The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Azure Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/azure_authn.htm) (`authn-azure`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaGCPCall

      public okhttp3.Call getAccessTokenViaGCPCall(String account, String acceptEncoding, String xRequestId, String jwt, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaGCP
      Parameters:
      account - Organization account name (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaGCP

      public String getAccessTokenViaGCP(String account, String acceptEncoding, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications running in Google Cloud Platform. Use the GCP Authenticator API to send an authentication request from a Google Cloud service to Conjur. For more information, see [the documentation](https://docs.conjur.org/Latest/en/Content/Operations/Services/cjr-gcp-authn.htm).
      Parameters:
      account - Organization account name (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaGCP

      public String getAccessTokenViaGCP(String account) throws ApiException
      Gets a short-lived access token for applications running in Google Cloud Platform. Use the GCP Authenticator API to send an authentication request from a Google Cloud service to Conjur. For more information, see [the documentation](https://docs.conjur.org/Latest/en/Content/Operations/Services/cjr-gcp-authn.htm).
      Parameters:
      account - Organization account name
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaGCPWithHttpInfo

      public ApiResponse<String> getAccessTokenViaGCPWithHttpInfo(String account, String acceptEncoding, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications running in Google Cloud Platform. Use the GCP Authenticator API to send an authentication request from a Google Cloud service to Conjur. For more information, see [the documentation](https://docs.conjur.org/Latest/en/Content/Operations/Services/cjr-gcp-authn.htm).
      Parameters:
      account - Organization account name (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaGCPWithHttpInfo

      public ApiResponse<String> getAccessTokenViaGCPWithHttpInfo(String account) throws ApiException
      Gets a short-lived access token for applications running in Google Cloud Platform. Use the GCP Authenticator API to send an authentication request from a Google Cloud service to Conjur. For more information, see [the documentation](https://docs.conjur.org/Latest/en/Content/Operations/Services/cjr-gcp-authn.htm).
      Parameters:
      account - Organization account name
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaGCPAsync

      public okhttp3.Call getAccessTokenViaGCPAsync(String account, String acceptEncoding, String xRequestId, String jwt, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token for applications running in Google Cloud Platform. (asynchronously) Use the GCP Authenticator API to send an authentication request from a Google Cloud service to Conjur. For more information, see [the documentation](https://docs.conjur.org/Latest/en/Content/Operations/Services/cjr-gcp-authn.htm).
      Parameters:
      account - Organization account name (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTCall

      public okhttp3.Call getAccessTokenViaJWTCall(String account, String serviceId, String xRequestId, String jwt, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaJWT
      Parameters:
      account - Organization account name (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWT

      public String getAccessTokenViaJWT(String account, String serviceId, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWT

      public String getAccessTokenViaJWT(String account, String serviceId) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name
      serviceId - URL-Encoded authenticator service ID
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithHttpInfo

      public ApiResponse<String> getAccessTokenViaJWTWithHttpInfo(String account, String serviceId, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithHttpInfo

      public ApiResponse<String> getAccessTokenViaJWTWithHttpInfo(String account, String serviceId) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name
      serviceId - URL-Encoded authenticator service ID
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTAsync

      public okhttp3.Call getAccessTokenViaJWTAsync(String account, String serviceId, String xRequestId, String jwt, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. (asynchronously) Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithIdCall

      public okhttp3.Call getAccessTokenViaJWTWithIdCall(String account, String id, String serviceId, String xRequestId, String jwt, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaJWTWithId
      Parameters:
      account - Organization account name (required)
      id - Organization user id (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithId

      public String getAccessTokenViaJWTWithId(String account, String id, String serviceId, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Covers the case of use of optional URL parameter \"ID\" Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name (required)
      id - Organization user id (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithId

      public String getAccessTokenViaJWTWithId(String account, String id, String serviceId) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Covers the case of use of optional URL parameter \"ID\" Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name
      id - Organization user id
      serviceId - URL-Encoded authenticator service ID
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithIdWithHttpInfo

      public ApiResponse<String> getAccessTokenViaJWTWithIdWithHttpInfo(String account, String id, String serviceId, String xRequestId, String jwt) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Covers the case of use of optional URL parameter \"ID\" Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name (required)
      id - Organization user id (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithIdWithHttpInfo

      public ApiResponse<String> getAccessTokenViaJWTWithIdWithHttpInfo(String account, String id, String serviceId) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Covers the case of use of optional URL parameter \"ID\" Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name
      id - Organization user id
      serviceId - URL-Encoded authenticator service ID
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaJWTWithIdAsync

      public okhttp3.Call getAccessTokenViaJWTWithIdAsync(String account, String id, String serviceId, String xRequestId, String jwt, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token for applications using JSON Web Token (JWT) to access the Conjur API. Covers the case of use of optional URL parameter \"ID\" (asynchronously) Use the JWT Authenticator to leverage the identity layer provided by JWT to authenticate with Conjur.
      Parameters:
      account - Organization account name (required)
      id - Organization user id (required)
      serviceId - URL-Encoded authenticator service ID (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      jwt - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaKubernetesCall

      public okhttp3.Call getAccessTokenViaKubernetesCall(String serviceId, String account, String login, String acceptEncoding, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaKubernetes
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaKubernetes

      public String getAccessTokenViaKubernetes(String serviceId, String account, String login, String acceptEncoding, String xRequestId) throws ApiException
      Gets a short-lived access token for applications running in Kubernetes. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Kubernetes Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/k8s_auth.htm) (`authn-k8s`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaKubernetes

      public String getAccessTokenViaKubernetes(String serviceId, String account, String login) throws ApiException
      Gets a short-lived access token for applications running in Kubernetes. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Kubernetes Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/k8s_auth.htm) (`authn-k8s`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaKubernetesWithHttpInfo

      public ApiResponse<String> getAccessTokenViaKubernetesWithHttpInfo(String serviceId, String account, String login, String acceptEncoding, String xRequestId) throws ApiException
      Gets a short-lived access token for applications running in Kubernetes. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Kubernetes Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/k8s_auth.htm) (`authn-k8s`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaKubernetesWithHttpInfo

      public ApiResponse<String> getAccessTokenViaKubernetesWithHttpInfo(String serviceId, String account, String login) throws ApiException
      Gets a short-lived access token for applications running in Kubernetes. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Kubernetes Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/k8s_auth.htm) (`authn-k8s`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaKubernetesAsync

      public okhttp3.Call getAccessTokenViaKubernetesAsync(String serviceId, String account, String login, String acceptEncoding, String xRequestId, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token for applications running in Kubernetes. (asynchronously) The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded and the host ID must have the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. To authenticate to Conjur using this endpoint, reference the detailed documentation: [Kubernetes Authenticator](https://docs.conjur.org/Latest/en/Content/Operations/Services/k8s_auth.htm) (`authn-k8s`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaLDAPCall

      public okhttp3.Call getAccessTokenViaLDAPCall(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String body, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaLDAP
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      body - API key (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaLDAP

      public String getAccessTokenViaLDAP(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String body) throws ApiException
      Gets a short-lived access token for users and hosts using their LDAP identity to access the Conjur API. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. To authenticate to Conjur using a LDAP, reference the detailed documentation: [LDAP Authenticator](https://docs.conjur.org/Latest/en/Content/Integrations/ldap/ldap_authenticator.html) (`authn-ldap`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      body - API key (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaLDAP

      public String getAccessTokenViaLDAP(String serviceId, String account, String login) throws ApiException
      Gets a short-lived access token for users and hosts using their LDAP identity to access the Conjur API. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. To authenticate to Conjur using a LDAP, reference the detailed documentation: [LDAP Authenticator](https://docs.conjur.org/Latest/en/Content/Integrations/ldap/ldap_authenticator.html) (`authn-ldap`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaLDAPWithHttpInfo

      public ApiResponse<String> getAccessTokenViaLDAPWithHttpInfo(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String body) throws ApiException
      Gets a short-lived access token for users and hosts using their LDAP identity to access the Conjur API. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. To authenticate to Conjur using a LDAP, reference the detailed documentation: [LDAP Authenticator](https://docs.conjur.org/Latest/en/Content/Integrations/ldap/ldap_authenticator.html) (`authn-ldap`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      body - API key (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaLDAPWithHttpInfo

      public ApiResponse<String> getAccessTokenViaLDAPWithHttpInfo(String serviceId, String account, String login) throws ApiException
      Gets a short-lived access token for users and hosts using their LDAP identity to access the Conjur API. The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. To authenticate to Conjur using a LDAP, reference the detailed documentation: [LDAP Authenticator](https://docs.conjur.org/Latest/en/Content/Integrations/ldap/ldap_authenticator.html) (`authn-ldap`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>`
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaLDAPAsync

      public okhttp3.Call getAccessTokenViaLDAPAsync(String serviceId, String account, String login, String acceptEncoding, String xRequestId, String body, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token for users and hosts using their LDAP identity to access the Conjur API. (asynchronously) The access token is used to communicate to the REST API that the bearer of the token has been authorized to access the API and perform specific actions specified by the scope that was granted during authorization. For API usage, the base64-encoded access token is ordinarily passed as an HTTP Authorization header as `Authorization: Token token=<base64-encoded token>`. The `login` must be URL encoded. For example, `alice@devops` must be encoded as `alice%40devops`. The `service_id`, if given, must be URL encoded. For example, `prod/gke` must be encoded as `prod%2Fgke`. For host authentication, the `login` is the host ID with the prefix `host/`. For example, the host webserver would login as `host/webserver`, and would be encoded as `host%2Fwebserver`. To authenticate to Conjur using a LDAP, reference the detailed documentation: [LDAP Authenticator](https://docs.conjur.org/Latest/en/Content/Integrations/ldap/ldap_authenticator.html) (`authn-ldap`).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      login - URL-encoded login name. For users, it’s the user ID. For hosts, the login name is `host/<host-id>` (required)
      acceptEncoding - Setting the Accept-Encoding header to base64 will return a pre-encoded access token (optional, default to application/json)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      body - API key (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -
      500 Malfromed request, rejected by the server -

    • getAccessTokenViaOIDCCall

      public okhttp3.Call getAccessTokenViaOIDCCall(String serviceId, String account, String xRequestId, String idToken, ApiCallback _callback) throws ApiException
      Build call for getAccessTokenViaOIDC
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      idToken - (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • getAccessTokenViaOIDC

      public String getAccessTokenViaOIDC(String serviceId, String account, String xRequestId, String idToken) throws ApiException
      Gets a short-lived access token for applications using OpenID Connect (OIDC) to access the Conjur API. Use the OIDC Authenticator to leverage the identity layer provided by OIDC to authenticate with Conjur. For more information see [the documentation](https://docs.conjur.org/Latest/en/Content/OIDC/OIDC.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      idToken - (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • getAccessTokenViaOIDC

      public String getAccessTokenViaOIDC(String serviceId, String account) throws ApiException
      Gets a short-lived access token for applications using OpenID Connect (OIDC) to access the Conjur API. Use the OIDC Authenticator to leverage the identity layer provided by OIDC to authenticate with Conjur. For more information see [the documentation](https://docs.conjur.org/Latest/en/Content/OIDC/OIDC.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • getAccessTokenViaOIDCWithHttpInfo

      public ApiResponse<String> getAccessTokenViaOIDCWithHttpInfo(String serviceId, String account, String xRequestId, String idToken) throws ApiException
      Gets a short-lived access token for applications using OpenID Connect (OIDC) to access the Conjur API. Use the OIDC Authenticator to leverage the identity layer provided by OIDC to authenticate with Conjur. For more information see [the documentation](https://docs.conjur.org/Latest/en/Content/OIDC/OIDC.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      idToken - (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • getAccessTokenViaOIDCWithHttpInfo

      public ApiResponse<String> getAccessTokenViaOIDCWithHttpInfo(String serviceId, String account) throws ApiException
      Gets a short-lived access token for applications using OpenID Connect (OIDC) to access the Conjur API. Use the OIDC Authenticator to leverage the identity layer provided by OIDC to authenticate with Conjur. For more information see [the documentation](https://docs.conjur.org/Latest/en/Content/OIDC/OIDC.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      account - Organization account name
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • getAccessTokenViaOIDCAsync

      public okhttp3.Call getAccessTokenViaOIDCAsync(String serviceId, String account, String xRequestId, String idToken, ApiCallback<String> _callback) throws ApiException
      Gets a short-lived access token for applications using OpenID Connect (OIDC) to access the Conjur API. (asynchronously) Use the OIDC Authenticator to leverage the identity layer provided by OIDC to authenticate with Conjur. For more information see [the documentation](https://docs.conjur.org/Latest/en/Content/OIDC/OIDC.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      account - Organization account name (required)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      idToken - (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response is an access token for conjur -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • k8sInjectClientCertCall

      public okhttp3.Call k8sInjectClientCertCall(String serviceId, String body, String hostIdPrefix, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for k8sInjectClientCert
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      body - Valid certificate signing request that includes the host identity suffix as the CSR common name (required)
      hostIdPrefix - Dot-separated policy tree, prefixed by `host.`, where the application identity is defined (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      202 The injected certificate was accepted. -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • k8sInjectClientCert

      public void k8sInjectClientCert(String serviceId, String body, String hostIdPrefix, String xRequestId) throws ApiException
      For applications running in Kubernetes; sends Conjur a certificate signing request (CSR) and requests a client certificate injected into the application's Kubernetes pod. This request sends a Certificate Signing Request to Conjur, which uses the Kubernetes API to inject a client certificate into the application pod. This endpoint requires a properly configured Conjur Certificate Authority service alongside a properly configured and enabled Kubernetes authenticator. For detailed instructions, see [the documentation](https://docs.conjur.org/Latest/en/Content/Integrations/kubernetes.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      body - Valid certificate signing request that includes the host identity suffix as the CSR common name (required)
      hostIdPrefix - Dot-separated policy tree, prefixed by `host.`, where the application identity is defined (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      202 The injected certificate was accepted. -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • k8sInjectClientCert

      public void k8sInjectClientCert(String serviceId, String body) throws ApiException
      For applications running in Kubernetes; sends Conjur a certificate signing request (CSR) and requests a client certificate injected into the application's Kubernetes pod. This request sends a Certificate Signing Request to Conjur, which uses the Kubernetes API to inject a client certificate into the application pod. This endpoint requires a properly configured Conjur Certificate Authority service alongside a properly configured and enabled Kubernetes authenticator. For detailed instructions, see [the documentation](https://docs.conjur.org/Latest/en/Content/Integrations/kubernetes.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      body - Valid certificate signing request that includes the host identity suffix as the CSR common name
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      202 The injected certificate was accepted. -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • k8sInjectClientCertWithHttpInfo

      public ApiResponse<Void> k8sInjectClientCertWithHttpInfo(String serviceId, String body, String hostIdPrefix, String xRequestId) throws ApiException
      For applications running in Kubernetes; sends Conjur a certificate signing request (CSR) and requests a client certificate injected into the application's Kubernetes pod. This request sends a Certificate Signing Request to Conjur, which uses the Kubernetes API to inject a client certificate into the application pod. This endpoint requires a properly configured Conjur Certificate Authority service alongside a properly configured and enabled Kubernetes authenticator. For detailed instructions, see [the documentation](https://docs.conjur.org/Latest/en/Content/Integrations/kubernetes.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      body - Valid certificate signing request that includes the host identity suffix as the CSR common name (required)
      hostIdPrefix - Dot-separated policy tree, prefixed by `host.`, where the application identity is defined (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      202 The injected certificate was accepted. -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • k8sInjectClientCertWithHttpInfo

      public ApiResponse<Void> k8sInjectClientCertWithHttpInfo(String serviceId, String body) throws ApiException
      For applications running in Kubernetes; sends Conjur a certificate signing request (CSR) and requests a client certificate injected into the application's Kubernetes pod. This request sends a Certificate Signing Request to Conjur, which uses the Kubernetes API to inject a client certificate into the application pod. This endpoint requires a properly configured Conjur Certificate Authority service alongside a properly configured and enabled Kubernetes authenticator. For detailed instructions, see [the documentation](https://docs.conjur.org/Latest/en/Content/Integrations/kubernetes.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID
      body - Valid certificate signing request that includes the host identity suffix as the CSR common name
      Returns:
      ApiResponse<Void>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      202 The injected certificate was accepted. -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • k8sInjectClientCertAsync

      public okhttp3.Call k8sInjectClientCertAsync(String serviceId, String body, String hostIdPrefix, String xRequestId, ApiCallback<Void> _callback) throws ApiException
      For applications running in Kubernetes; sends Conjur a certificate signing request (CSR) and requests a client certificate injected into the application's Kubernetes pod. (asynchronously) This request sends a Certificate Signing Request to Conjur, which uses the Kubernetes API to inject a client certificate into the application pod. This endpoint requires a properly configured Conjur Certificate Authority service alongside a properly configured and enabled Kubernetes authenticator. For detailed instructions, see [the documentation](https://docs.conjur.org/Latest/en/Content/Integrations/kubernetes.htm).
      Parameters:
      serviceId - URL-Encoded authenticator service ID (required)
      body - Valid certificate signing request that includes the host identity suffix as the CSR common name (required)
      hostIdPrefix - Dot-separated policy tree, prefixed by `host.`, where the application identity is defined (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      202 The injected certificate was accepted. -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      404 The requested resource does not exist, the authenticated user lacks the required privileges to enumerate this resource, or its value has not been set -

    • rotateApiKeyCall

      public okhttp3.Call rotateApiKeyCall(String account, String role, String xRequestId, ApiCallback _callback) throws ApiException
      Build call for rotateApiKey
      Parameters:
      account - Organization account name (required)
      role - (**Optional**) role specifier in `{kind}:{identifier}` format ##### Permissions required `update` privilege on the role whose API key is being rotated. (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - Callback for upload/download progress
      Returns:
      Call to execute
      Throws:
      ApiException - If fail to serialize the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • rotateApiKey

      public String rotateApiKey(String account, String role, String xRequestId) throws ApiException
      Rotates a role's API key. Any role can rotate its own API key. The name and password (for users) or current API key (for hosts and users) of the role must be provided via HTTP Basic Authorization. To rotate another role's API key, you may provide your name and password (for users) or current API key (for hosts and users) via HTTP Basic Authorization with the request. Alternatively, you may provide your Conjur access token via the standard Conjur `Authorization` header. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. If using the Conjur `Authorization` header, its value should be set to `Token token=<base64-encoded access token>`. Note that the body of the request must be the empty string.
      Parameters:
      account - Organization account name (required)
      role - (**Optional**) role specifier in `{kind}:{identifier}` format ##### Permissions required `update` privilege on the role whose API key is being rotated. (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • rotateApiKey

      public String rotateApiKey(String account) throws ApiException
      Rotates a role's API key. Any role can rotate its own API key. The name and password (for users) or current API key (for hosts and users) of the role must be provided via HTTP Basic Authorization. To rotate another role's API key, you may provide your name and password (for users) or current API key (for hosts and users) via HTTP Basic Authorization with the request. Alternatively, you may provide your Conjur access token via the standard Conjur `Authorization` header. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. If using the Conjur `Authorization` header, its value should be set to `Token token=<base64-encoded access token>`. Note that the body of the request must be the empty string.
      Parameters:
      account - Organization account name
      Returns:
      String
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • rotateApiKeyWithHttpInfo

      public ApiResponse<String> rotateApiKeyWithHttpInfo(String account, String role, String xRequestId) throws ApiException
      Rotates a role's API key. Any role can rotate its own API key. The name and password (for users) or current API key (for hosts and users) of the role must be provided via HTTP Basic Authorization. To rotate another role's API key, you may provide your name and password (for users) or current API key (for hosts and users) via HTTP Basic Authorization with the request. Alternatively, you may provide your Conjur access token via the standard Conjur `Authorization` header. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. If using the Conjur `Authorization` header, its value should be set to `Token token=<base64-encoded access token>`. Note that the body of the request must be the empty string.
      Parameters:
      account - Organization account name (required)
      role - (**Optional**) role specifier in `{kind}:{identifier}` format ##### Permissions required `update` privilege on the role whose API key is being rotated. (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • rotateApiKeyWithHttpInfo

      public ApiResponse<String> rotateApiKeyWithHttpInfo(String account) throws ApiException
      Rotates a role's API key. Any role can rotate its own API key. The name and password (for users) or current API key (for hosts and users) of the role must be provided via HTTP Basic Authorization. To rotate another role's API key, you may provide your name and password (for users) or current API key (for hosts and users) via HTTP Basic Authorization with the request. Alternatively, you may provide your Conjur access token via the standard Conjur `Authorization` header. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. If using the Conjur `Authorization` header, its value should be set to `Token token=<base64-encoded access token>`. Note that the body of the request must be the empty string.
      Parameters:
      account - Organization account name
      Returns:
      ApiResponse<String>
      Throws:
      ApiException - If fail to call the API, e.g. server error or cannot deserialize the response body
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -

    • rotateApiKeyAsync

      public okhttp3.Call rotateApiKeyAsync(String account, String role, String xRequestId, ApiCallback<String> _callback) throws ApiException
      Rotates a role's API key. (asynchronously) Any role can rotate its own API key. The name and password (for users) or current API key (for hosts and users) of the role must be provided via HTTP Basic Authorization. To rotate another role's API key, you may provide your name and password (for users) or current API key (for hosts and users) via HTTP Basic Authorization with the request. Alternatively, you may provide your Conjur access token via the standard Conjur `Authorization` header. The Basic authentication-compliant header is formed by: 1. Concatenating the role's name, a literal colon character ':', and the password or API key to create the authentication string. 2. Base64-encoding the authentication string. 3. Prefixing the authentication string with the scheme: `Basic ` (note the required space). 4. Providing the result as the value of the `Authorization` HTTP header: `Authorization: Basic <authentication string>`. Your HTTP/REST client probably provides HTTP basic authentication support. For example, `curl` and all of the Conjur client libraries provide this. If using the Conjur `Authorization` header, its value should be set to `Token token=<base64-encoded access token>`. Note that the body of the request must be the empty string.
      Parameters:
      account - Organization account name (required)
      role - (**Optional**) role specifier in `{kind}:{identifier}` format ##### Permissions required `update` privilege on the role whose API key is being rotated. (optional)
      xRequestId - Add an ID to the request being made so it can be tracked in Conjur. If not provided the server will automatically generate one. (optional)
      _callback - The callback to be executed when the API call finishes
      Returns:
      The request call
      Throws:
      ApiException - If fail to process the API call, e.g. serializing the request body object
      Http Response Details:
      Status Code Description Response Headers
      200 The response body is the API key -
      400 The server cannot process the request due to malformed request syntax -
      401 Authentication information is missing or invalid -
      422 A request parameter was either missing or invalid. -
      500 Malfromed request, rejected by the server -