api_secrets.go

/*
HashiCorp Vault API

HTTP API that gives you full access to Vault. All API routes are prefixed with `/v1/`.

API version: 1.13.0
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package vault

import (
	"context"
	"net/http"
	"net/url"
	"strings"
)

// Secrets is a simple wrapper around the client for Secrets requests
type Secrets struct {
	client *Client
}

// DeleteAdConfig Configure the AD server to connect to, along with password options.
func (a *Secrets) DeleteAdConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteAdLibraryName Delete a library set.
// name: Name of the set.
func (a *Secrets) DeleteAdLibraryName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteAdRolesName Manage roles to build links between Vault and Active Directory service accounts.
// name: Name of the role
func (a *Secrets) DeleteAdRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteAlicloudConfig Configure the access key and secret to use for RAM and STS calls.
func (a *Secrets) DeleteAlicloudConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteAlicloudRoleName Read, write and reference policies and roles that API keys or STS credentials can be made for.
// name: The name of the role.
func (a *Secrets) DeleteAlicloudRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteAwsRolesName Read, write and reference IAM policies that access keys can be made for.
// name: Name of the policy
func (a *Secrets) DeleteAwsRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteAzureConfig
func (a *Secrets) DeleteAzureConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteAzureRolesName Manage the Vault roles used to generate Azure credentials.
// name: Name of the role.
func (a *Secrets) DeleteAzureRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteConsulRolesName
// name: Name of the role.
func (a *Secrets) DeleteConsulRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{consul_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"consul_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("consul")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteCubbyholePath Deletes the secret at the specified location.
// path: Specifies the path of the secret.
func (a *Secrets) DeleteCubbyholePath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{cubbyhole_mount_path}/{path}"
	requestPath = strings.Replace(requestPath, "{"+"cubbyhole_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("cubbyhole")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteGcpRolesetName
// name: Required. Name of the role.
func (a *Secrets) DeleteGcpRolesetName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{name}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteGcpStaticAccountName
// name: Required. Name to refer to this static account in Vault. Cannot be updated.
func (a *Secrets) DeleteGcpStaticAccountName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteGcpkmsConfig Configure the GCP KMS secrets engine
func (a *Secrets) DeleteGcpkmsConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteGcpkmsKeysDeregisterKey Deregister an existing key in Vault
// key: Name of the key to deregister in Vault. If the key exists in Google Cloud KMS, it will be left untouched.
func (a *Secrets) DeleteGcpkmsKeysDeregisterKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/deregister/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteGcpkmsKeysKey Interact with crypto keys in Vault and Google Cloud KMS
// key: Name of the key in Vault.
func (a *Secrets) DeleteGcpkmsKeysKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteGcpkmsKeysTrimKey Delete old crypto key versions from Google Cloud KMS
// key: Name of the key in Vault.
func (a *Secrets) DeleteGcpkmsKeysTrimKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/trim/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteKubernetesConfig
func (a *Secrets) DeleteKubernetesConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteKubernetesRolesName
// name: Name of the role
func (a *Secrets) DeleteKubernetesRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteLdapConfig
func (a *Secrets) DeleteLdapConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteLdapLibraryName Delete a library set.
// name: Name of the set.
func (a *Secrets) DeleteLdapLibraryName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteLdapRoleName
// name: Name of the role (lowercase)
func (a *Secrets) DeleteLdapRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteLdapStaticRoleName
// name: Name of the role
func (a *Secrets) DeleteLdapStaticRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/static-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteMongodbatlasRolesName Manage the roles used to generate MongoDB Atlas Programmatic API Keys.
// name: Name of the Roles
func (a *Secrets) DeleteMongodbatlasRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteNomadConfigAccess
func (a *Secrets) DeleteNomadConfigAccess(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/config/access"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteNomadConfigLease Configure the lease parameters for generated tokens
func (a *Secrets) DeleteNomadConfigLease(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/config/lease"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteNomadRoleName
// name: Name of the role
func (a *Secrets) DeleteNomadRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteOpenldapConfig
func (a *Secrets) DeleteOpenldapConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteOpenldapLibraryName Delete a library set.
// name: Name of the set.
func (a *Secrets) DeleteOpenldapLibraryName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteOpenldapRoleName
// name: Name of the role (lowercase)
func (a *Secrets) DeleteOpenldapRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteOpenldapStaticRoleName
// name: Name of the role
func (a *Secrets) DeleteOpenldapStaticRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/static-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeletePkiIssuerRefDerPem
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) DeletePkiIssuerRefDerPem(ctx context.Context, issuerRef string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/{issuer_ref}/der|/pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeletePkiJson
func (a *Secrets) DeletePkiJson(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}//json"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeletePkiKeyKeyRef
// keyRef: Reference to key; either \"default\" for the configured default key, an identifier of a key, or the name assigned to the key.
func (a *Secrets) DeletePkiKeyKeyRef(ctx context.Context, keyRef string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/key/{key_ref}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key_ref"+"}", url.PathEscape(keyRef), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeletePkiRolesName
// name: Name of the role
func (a *Secrets) DeletePkiRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeletePkiRoot
func (a *Secrets) DeletePkiRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/root"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteRabbitmqRolesName Manage the roles that can be created with this backend.
// name: Name of the role.
func (a *Secrets) DeleteRabbitmqRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteSecretDataPath Write, Patch, Read, and Delete data in the Key-Value Store.
// path: Location of the secret.
func (a *Secrets) DeleteSecretDataPath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/data/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteSecretMetadataPath Configures settings for the KV store
// path: Location of the secret.
func (a *Secrets) DeleteSecretMetadataPath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/metadata/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteSecretPath Pass-through secret storage to the storage backend, allowing you to read/write arbitrary data into secret storage.
// path: Location of the secret.
func (a *Secrets) DeleteSecretPath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteSshConfigCa Set the SSH private key used for signing certificates.
func (a *Secrets) DeleteSshConfigCa(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/config/ca"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteSshConfigZeroaddress Assign zero address as default CIDR block for select roles.
func (a *Secrets) DeleteSshConfigZeroaddress(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/config/zeroaddress"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteSshKeysKeyName Register a shared private key with Vault.
// keyName: [Required] Name of the key
func (a *Secrets) DeleteSshKeysKeyName(ctx context.Context, keyName string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/keys/{key_name}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key_name"+"}", url.PathEscape(keyName), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteSshRolesRole Manage the 'roles' that can be created with this backend.
// role: [Required for all types] Name of the role being created.
func (a *Secrets) DeleteSshRolesRole(ctx context.Context, role string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/roles/{role}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteTerraformConfig
func (a *Secrets) DeleteTerraformConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteTerraformRoleName
// name: Name of the role
func (a *Secrets) DeleteTerraformRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteTotpKeysName Manage the keys that can be created with this backend.
// name: Name of the key.
func (a *Secrets) DeleteTotpKeysName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{totp_mount_path}/keys/{name}"
	requestPath = strings.Replace(requestPath, "{"+"totp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("totp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// DeleteTransitKeysName Managed named encryption keys
// name: Name of the key
func (a *Secrets) DeleteTransitKeysName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodDelete,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdConfig Configure the AD server to connect to, along with password options.
func (a *Secrets) GetAdConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdCredsName
// name: Name of the role
func (a *Secrets) GetAdCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdLibrary
// list: Must be set to `true`
func (a *Secrets) GetAdLibrary(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdLibraryName Read a library set.
// name: Name of the set.
func (a *Secrets) GetAdLibraryName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdLibraryNameStatus Check the status of the service accounts in a library set.
// name: Name of the set.
func (a *Secrets) GetAdLibraryNameStatus(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library/{name}/status"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdRoles List the name of each role currently stored.
// list: Must be set to `true`
func (a *Secrets) GetAdRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdRolesName Manage roles to build links between Vault and Active Directory service accounts.
// name: Name of the role
func (a *Secrets) GetAdRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAdRotateRoot
func (a *Secrets) GetAdRotateRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/rotate-root"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAlicloudConfig Configure the access key and secret to use for RAM and STS calls.
func (a *Secrets) GetAlicloudConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAlicloudCredsName Generate an API key or STS credential using the given role's configuration.'
// name: The name of the role.
func (a *Secrets) GetAlicloudCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAlicloudRole List the existing roles in this backend.
// list: Must be set to `true`
func (a *Secrets) GetAlicloudRole(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/role"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAlicloudRoleName Read, write and reference policies and roles that API keys or STS credentials can be made for.
// name: The name of the role.
func (a *Secrets) GetAlicloudRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAwsConfigLease Configure the default lease information for generated credentials.
func (a *Secrets) GetAwsConfigLease(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/config/lease"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAwsConfigRoot Configure the root credentials that are used to manage IAM.
func (a *Secrets) GetAwsConfigRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/config/root"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAwsCreds Generate AWS credentials from a specific Vault role.
func (a *Secrets) GetAwsCreds(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/creds"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAwsRoles List the existing roles in this backend
// list: Must be set to `true`
func (a *Secrets) GetAwsRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAwsRolesName Read, write and reference IAM policies that access keys can be made for.
// name: Name of the policy
func (a *Secrets) GetAwsRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAwsStsName Generate AWS credentials from a specific Vault role.
// name: Name of the role
func (a *Secrets) GetAwsStsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/sts/{name}"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAzureConfig
func (a *Secrets) GetAzureConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAzureCredsRole
// role: Name of the Vault role
func (a *Secrets) GetAzureCredsRole(ctx context.Context, role string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/creds/{role}"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAzureRoles List existing roles.
// list: Must be set to `true`
func (a *Secrets) GetAzureRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetAzureRolesName Manage the Vault roles used to generate Azure credentials.
// name: Name of the role.
func (a *Secrets) GetAzureRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetConsulConfigAccess
func (a *Secrets) GetConsulConfigAccess(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{consul_mount_path}/config/access"
	requestPath = strings.Replace(requestPath, "{"+"consul_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("consul")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetConsulCredsRole
// role: Name of the role.
func (a *Secrets) GetConsulCredsRole(ctx context.Context, role string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{consul_mount_path}/creds/{role}"
	requestPath = strings.Replace(requestPath, "{"+"consul_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("consul")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetConsulRoles
// list: Must be set to `true`
func (a *Secrets) GetConsulRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{consul_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"consul_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("consul")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetConsulRolesName
// name: Name of the role.
func (a *Secrets) GetConsulRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{consul_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"consul_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("consul")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetCubbyholePath Retrieve the secret at the specified location.
// path: Specifies the path of the secret.
func (a *Secrets) GetCubbyholePath(ctx context.Context, path string, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{cubbyhole_mount_path}/{path}"
	requestPath = strings.Replace(requestPath, "{"+"cubbyhole_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("cubbyhole")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpConfig
func (a *Secrets) GetGcpConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpKeyRoleset
// roleset: Required. Name of the role set.
func (a *Secrets) GetGcpKeyRoleset(ctx context.Context, roleset string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/key/{roleset}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpRolesetName
// name: Required. Name of the role.
func (a *Secrets) GetGcpRolesetName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{name}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpRolesetRolesetKey
// roleset: Required. Name of the role set.
func (a *Secrets) GetGcpRolesetRolesetKey(ctx context.Context, roleset string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{roleset}/key"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpRolesetRolesetToken
// roleset: Required. Name of the role set.
func (a *Secrets) GetGcpRolesetRolesetToken(ctx context.Context, roleset string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{roleset}/token"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpRolesets
// list: Must be set to `true`
func (a *Secrets) GetGcpRolesets(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/rolesets"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpStaticAccountName
// name: Required. Name to refer to this static account in Vault. Cannot be updated.
func (a *Secrets) GetGcpStaticAccountName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpStaticAccountNameKey
// name: Required. Name of the static account.
func (a *Secrets) GetGcpStaticAccountNameKey(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}/key"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpStaticAccountNameToken
// name: Required. Name of the static account.
func (a *Secrets) GetGcpStaticAccountNameToken(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}/token"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpStaticAccounts
// list: Must be set to `true`
func (a *Secrets) GetGcpStaticAccounts(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-accounts"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpTokenRoleset
// roleset: Required. Name of the role set.
func (a *Secrets) GetGcpTokenRoleset(ctx context.Context, roleset string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/token/{roleset}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpkmsConfig Configure the GCP KMS secrets engine
func (a *Secrets) GetGcpkmsConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpkmsKeys List named keys
// list: Must be set to `true`
func (a *Secrets) GetGcpkmsKeys(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpkmsKeysConfigKey Configure the key in Vault
// key: Name of the key in Vault.
func (a *Secrets) GetGcpkmsKeysConfigKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/config/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpkmsKeysKey Interact with crypto keys in Vault and Google Cloud KMS
// key: Name of the key in Vault.
func (a *Secrets) GetGcpkmsKeysKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetGcpkmsPubkeyKey Retrieve the public key associated with the named key
// key: Name of the key for which to get the public key. This key must already exist in Vault and Google Cloud KMS.
func (a *Secrets) GetGcpkmsPubkeyKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/pubkey/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetKubernetesConfig
func (a *Secrets) GetKubernetesConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetKubernetesRoles
// list: Must be set to `true`
func (a *Secrets) GetKubernetesRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetKubernetesRolesName
// name: Name of the role
func (a *Secrets) GetKubernetesRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapConfig
func (a *Secrets) GetLdapConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapCredsName
// name: Name of the dynamic role.
func (a *Secrets) GetLdapCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapLibrary
// list: Must be set to `true`
func (a *Secrets) GetLdapLibrary(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapLibraryName Read a library set.
// name: Name of the set.
func (a *Secrets) GetLdapLibraryName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapLibraryNameStatus Check the status of the service accounts in a library set.
// name: Name of the set.
func (a *Secrets) GetLdapLibraryNameStatus(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library/{name}/status"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapRole
// list: Must be set to `true`
func (a *Secrets) GetLdapRole(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/role"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapRoleName
// name: Name of the role (lowercase)
func (a *Secrets) GetLdapRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapStaticCredName
// name: Name of the static role.
func (a *Secrets) GetLdapStaticCredName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/static-cred/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapStaticRole
// list: Must be set to `true`
func (a *Secrets) GetLdapStaticRole(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/static-role"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetLdapStaticRoleName
// name: Name of the role
func (a *Secrets) GetLdapStaticRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/static-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetMongodbatlasConfig Configure the  credentials that are used to manage Database Users.
func (a *Secrets) GetMongodbatlasConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetMongodbatlasCredsName Generate MongoDB Atlas Programmatic API from a specific Vault role.
// name: Name of the role
func (a *Secrets) GetMongodbatlasCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetMongodbatlasRoles List the existing roles in this backend
// list: Must be set to `true`
func (a *Secrets) GetMongodbatlasRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetMongodbatlasRolesName Manage the roles used to generate MongoDB Atlas Programmatic API Keys.
// name: Name of the Roles
func (a *Secrets) GetMongodbatlasRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetNomadConfigAccess
func (a *Secrets) GetNomadConfigAccess(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/config/access"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetNomadConfigLease Configure the lease parameters for generated tokens
func (a *Secrets) GetNomadConfigLease(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/config/lease"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetNomadCredsName
// name: Name of the role
func (a *Secrets) GetNomadCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetNomadRole
// list: Must be set to `true`
func (a *Secrets) GetNomadRole(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/role"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetNomadRoleName
// name: Name of the role
func (a *Secrets) GetNomadRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapConfig
func (a *Secrets) GetOpenldapConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapCredsName
// name: Name of the dynamic role.
func (a *Secrets) GetOpenldapCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapLibrary
// list: Must be set to `true`
func (a *Secrets) GetOpenldapLibrary(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapLibraryName Read a library set.
// name: Name of the set.
func (a *Secrets) GetOpenldapLibraryName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapLibraryNameStatus Check the status of the service accounts in a library set.
// name: Name of the set.
func (a *Secrets) GetOpenldapLibraryNameStatus(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library/{name}/status"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapRole
// list: Must be set to `true`
func (a *Secrets) GetOpenldapRole(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/role"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapRoleName
// name: Name of the role (lowercase)
func (a *Secrets) GetOpenldapRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapStaticCredName
// name: Name of the static role.
func (a *Secrets) GetOpenldapStaticCredName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/static-cred/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapStaticRole
// list: Must be set to `true`
func (a *Secrets) GetOpenldapStaticRole(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/static-role"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetOpenldapStaticRoleName
// name: Name of the role
func (a *Secrets) GetOpenldapStaticRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/static-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCa
func (a *Secrets) GetPkiCa(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/ca"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCaChain
func (a *Secrets) GetPkiCaChain(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/ca_chain"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCaPem
func (a *Secrets) GetPkiCaPem(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/ca/pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCertCaChain
func (a *Secrets) GetPkiCertCaChain(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/cert/ca_chain"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCertSerial
// serial: Certificate serial number, in colon- or hyphen-separated octal
func (a *Secrets) GetPkiCertSerial(ctx context.Context, serial string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/cert/{serial}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"serial"+"}", url.PathEscape(serial), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCertSerialRaw
// serial: Certificate serial number, in colon- or hyphen-separated octal
func (a *Secrets) GetPkiCertSerialRaw(ctx context.Context, serial string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/cert/{serial}/raw"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"serial"+"}", url.PathEscape(serial), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCertSerialRawPem
// serial: Certificate serial number, in colon- or hyphen-separated octal
func (a *Secrets) GetPkiCertSerialRawPem(ctx context.Context, serial string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/cert/{serial}/raw/pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"serial"+"}", url.PathEscape(serial), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCerts
// list: Must be set to `true`
func (a *Secrets) GetPkiCerts(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/certs"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCertsRevoked
// list: Must be set to `true`
func (a *Secrets) GetPkiCertsRevoked(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/certs/revoked"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiConfigAutoTidy
func (a *Secrets) GetPkiConfigAutoTidy(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/auto-tidy"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiConfigCluster
func (a *Secrets) GetPkiConfigCluster(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/cluster"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiConfigCrl
func (a *Secrets) GetPkiConfigCrl(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/crl"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiConfigIssuers
func (a *Secrets) GetPkiConfigIssuers(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/issuers"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiConfigKeys
func (a *Secrets) GetPkiConfigKeys(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/keys"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiConfigUrls
func (a *Secrets) GetPkiConfigUrls(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/urls"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCrl
func (a *Secrets) GetPkiCrl(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/crl"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCrlRotate
func (a *Secrets) GetPkiCrlRotate(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/crl/rotate"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiCrlRotateDelta
func (a *Secrets) GetPkiCrlRotateDelta(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/crl/rotate-delta"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiDelta
func (a *Secrets) GetPkiDelta(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}//delta"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiDeltaCrl
func (a *Secrets) GetPkiDeltaCrl(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/delta-crl"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiDeltaPem
func (a *Secrets) GetPkiDeltaPem(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}//delta/pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiDer
func (a *Secrets) GetPkiDer(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}//der"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiIssuerRefCrlPemDerDeltaPem
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) GetPkiIssuerRefCrlPemDerDeltaPem(ctx context.Context, issuerRef string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/{issuer_ref}/crl/pem|/der|/delta/pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiIssuerRefDerPem
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) GetPkiIssuerRefDerPem(ctx context.Context, issuerRef string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/{issuer_ref}/der|/pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiIssuers
// list: Must be set to `true`
func (a *Secrets) GetPkiIssuers(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuers"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiJson
func (a *Secrets) GetPkiJson(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}//json"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiKeyKeyRef
// keyRef: Reference to key; either \"default\" for the configured default key, an identifier of a key, or the name assigned to the key.
func (a *Secrets) GetPkiKeyKeyRef(ctx context.Context, keyRef string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/key/{key_ref}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key_ref"+"}", url.PathEscape(keyRef), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiKeys
// list: Must be set to `true`
func (a *Secrets) GetPkiKeys(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/keys"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiOcspReq
// req: base-64 encoded ocsp request
func (a *Secrets) GetPkiOcspReq(ctx context.Context, req string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/ocsp/{req}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"req"+"}", url.PathEscape(req), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiPem
func (a *Secrets) GetPkiPem(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}//pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiRoles
// list: Must be set to `true`
func (a *Secrets) GetPkiRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiRolesName
// name: Name of the role
func (a *Secrets) GetPkiRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetPkiTidyStatus
func (a *Secrets) GetPkiTidyStatus(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/tidy-status"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetRabbitmqConfigLease Configure the lease parameters for generated credentials
func (a *Secrets) GetRabbitmqConfigLease(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/config/lease"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetRabbitmqCredsName Request RabbitMQ credentials for a certain role.
// name: Name of the role.
func (a *Secrets) GetRabbitmqCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetRabbitmqRoles Manage the roles that can be created with this backend.
// list: Must be set to `true`
func (a *Secrets) GetRabbitmqRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetRabbitmqRolesName Manage the roles that can be created with this backend.
// name: Name of the role.
func (a *Secrets) GetRabbitmqRolesName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSecretConfig Read the backend level settings.
func (a *Secrets) GetSecretConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSecretDataPath Write, Patch, Read, and Delete data in the Key-Value Store.
// path: Location of the secret.
func (a *Secrets) GetSecretDataPath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/data/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSecretMetadataPath Configures settings for the KV store
// path: Location of the secret.
func (a *Secrets) GetSecretMetadataPath(ctx context.Context, path string, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/metadata/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSecretPath Pass-through secret storage to the storage backend, allowing you to read/write arbitrary data into secret storage.
// path: Location of the secret.
func (a *Secrets) GetSecretPath(ctx context.Context, path string, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSecretSubkeysPath Read the structure of a secret entry from the Key-Value store with the values removed.
// path: Location of the secret.
func (a *Secrets) GetSecretSubkeysPath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/subkeys/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSshConfigCa Set the SSH private key used for signing certificates.
func (a *Secrets) GetSshConfigCa(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/config/ca"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSshConfigZeroaddress Assign zero address as default CIDR block for select roles.
func (a *Secrets) GetSshConfigZeroaddress(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/config/zeroaddress"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSshPublicKey Retrieve the public key.
func (a *Secrets) GetSshPublicKey(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/public_key"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSshRoles Manage the 'roles' that can be created with this backend.
// list: Must be set to `true`
func (a *Secrets) GetSshRoles(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/roles"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetSshRolesRole Manage the 'roles' that can be created with this backend.
// role: [Required for all types] Name of the role being created.
func (a *Secrets) GetSshRolesRole(ctx context.Context, role string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/roles/{role}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTerraformConfig
func (a *Secrets) GetTerraformConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTerraformCredsName Generate a Terraform Cloud or Enterprise API token from a specific Vault role.
// name: Name of the role
func (a *Secrets) GetTerraformCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTerraformRole
// list: Must be set to `true`
func (a *Secrets) GetTerraformRole(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/role"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTerraformRoleName
// name: Name of the role
func (a *Secrets) GetTerraformRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTotpCodeName Request time-based one-time use password or validate a password for a certain key .
// name: Name of the key.
func (a *Secrets) GetTotpCodeName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{totp_mount_path}/code/{name}"
	requestPath = strings.Replace(requestPath, "{"+"totp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("totp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTotpKeys Manage the keys that can be created with this backend.
// list: Must be set to `true`
func (a *Secrets) GetTotpKeys(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{totp_mount_path}/keys"
	requestPath = strings.Replace(requestPath, "{"+"totp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("totp")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTotpKeysName Manage the keys that can be created with this backend.
// name: Name of the key.
func (a *Secrets) GetTotpKeysName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{totp_mount_path}/keys/{name}"
	requestPath = strings.Replace(requestPath, "{"+"totp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("totp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTransitBackupName Backup the named key
// name: Name of the key
func (a *Secrets) GetTransitBackupName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/backup/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTransitCacheConfig Returns the size of the active cache
func (a *Secrets) GetTransitCacheConfig(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/cache-config"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTransitExportTypeName Export named encryption or signing key
// name: Name of the key
// type_: Type of key to export (encryption-key, signing-key, hmac-key)
func (a *Secrets) GetTransitExportTypeName(ctx context.Context, name string, type_ string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/export/{type}/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)
	requestPath = strings.Replace(requestPath, "{"+"type"+"}", url.PathEscape(type_), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTransitExportTypeNameVersion Export named encryption or signing key
// name: Name of the key
// type_: Type of key to export (encryption-key, signing-key, hmac-key)
// version: Version of the key
func (a *Secrets) GetTransitExportTypeNameVersion(ctx context.Context, name string, type_ string, version string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/export/{type}/{name}/{version}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)
	requestPath = strings.Replace(requestPath, "{"+"type"+"}", url.PathEscape(type_), -1)
	requestPath = strings.Replace(requestPath, "{"+"version"+"}", url.PathEscape(version), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTransitKeys Managed named encryption keys
// list: Must be set to `true`
func (a *Secrets) GetTransitKeys(ctx context.Context, list string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTransitKeysName Managed named encryption keys
// name: Name of the key
func (a *Secrets) GetTransitKeysName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// GetTransitWrappingKey Returns the public key to use for wrapping imported keys
func (a *Secrets) GetTransitWrappingKey(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/wrapping_key"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodGet,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdConfig Configure the AD server to connect to, along with password options.
func (a *Secrets) PostAdConfig(ctx context.Context, adConfigRequest AdConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		adConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdLibraryManageNameCheckIn Check service accounts in to the library.
// name: Name of the set.
func (a *Secrets) PostAdLibraryManageNameCheckIn(ctx context.Context, name string, adLibraryManageCheckInRequest AdLibraryManageCheckInRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library/manage/{name}/check-in"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		adLibraryManageCheckInRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdLibraryName Update a library set.
// name: Name of the set.
func (a *Secrets) PostAdLibraryName(ctx context.Context, name string, adLibraryRequest AdLibraryRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		adLibraryRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdLibraryNameCheckIn Check service accounts in to the library.
// name: Name of the set.
func (a *Secrets) PostAdLibraryNameCheckIn(ctx context.Context, name string, adLibraryCheckInRequest AdLibraryCheckInRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library/{name}/check-in"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		adLibraryCheckInRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdLibraryNameCheckOut Check a service account out from the library.
// name: Name of the set
func (a *Secrets) PostAdLibraryNameCheckOut(ctx context.Context, name string, adLibraryCheckOutRequest AdLibraryCheckOutRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/library/{name}/check-out"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		adLibraryCheckOutRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdRolesName Manage roles to build links between Vault and Active Directory service accounts.
// name: Name of the role
func (a *Secrets) PostAdRolesName(ctx context.Context, name string, adRolesRequest AdRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		adRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdRotateRoleName
// name: Name of the static role
func (a *Secrets) PostAdRotateRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/rotate-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAdRotateRoot
func (a *Secrets) PostAdRotateRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ad_mount_path}/rotate-root"
	requestPath = strings.Replace(requestPath, "{"+"ad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ad")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAlicloudConfig Configure the access key and secret to use for RAM and STS calls.
func (a *Secrets) PostAlicloudConfig(ctx context.Context, alicloudConfigRequest AlicloudConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		alicloudConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAlicloudRoleName Read, write and reference policies and roles that API keys or STS credentials can be made for.
// name: The name of the role.
func (a *Secrets) PostAlicloudRoleName(ctx context.Context, name string, alicloudRoleRequest AlicloudRoleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{alicloud_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"alicloud_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("alicloud")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		alicloudRoleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAwsConfigLease Configure the default lease information for generated credentials.
func (a *Secrets) PostAwsConfigLease(ctx context.Context, awsConfigLeaseRequest AwsConfigLeaseRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/config/lease"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		awsConfigLeaseRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAwsConfigRoot Configure the root credentials that are used to manage IAM.
func (a *Secrets) PostAwsConfigRoot(ctx context.Context, awsConfigRootRequest AwsConfigRootRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/config/root"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		awsConfigRootRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAwsConfigRotateRoot
func (a *Secrets) PostAwsConfigRotateRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/config/rotate-root"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAwsCreds Generate AWS credentials from a specific Vault role.
func (a *Secrets) PostAwsCreds(ctx context.Context, awsCredsRequest AwsCredsRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/creds"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		awsCredsRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAwsRolesName Read, write and reference IAM policies that access keys can be made for.
// name: Name of the policy
func (a *Secrets) PostAwsRolesName(ctx context.Context, name string, awsRolesRequest AwsRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		awsRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAwsStsName Generate AWS credentials from a specific Vault role.
// name: Name of the role
func (a *Secrets) PostAwsStsName(ctx context.Context, name string, awsStsRequest AwsStsRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{aws_mount_path}/sts/{name}"
	requestPath = strings.Replace(requestPath, "{"+"aws_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("aws")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		awsStsRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAzureConfig
func (a *Secrets) PostAzureConfig(ctx context.Context, azureConfigRequest AzureConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		azureConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAzureRolesName Manage the Vault roles used to generate Azure credentials.
// name: Name of the role.
func (a *Secrets) PostAzureRolesName(ctx context.Context, name string, azureRolesRequest AzureRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		azureRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostAzureRotateRoot
func (a *Secrets) PostAzureRotateRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{azure_mount_path}/rotate-root"
	requestPath = strings.Replace(requestPath, "{"+"azure_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("azure")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostConsulConfigAccess
func (a *Secrets) PostConsulConfigAccess(ctx context.Context, consulConfigAccessRequest ConsulConfigAccessRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{consul_mount_path}/config/access"
	requestPath = strings.Replace(requestPath, "{"+"consul_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("consul")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		consulConfigAccessRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostConsulRolesName
// name: Name of the role.
func (a *Secrets) PostConsulRolesName(ctx context.Context, name string, consulRolesRequest ConsulRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{consul_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"consul_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("consul")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		consulRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostCubbyholePath Store a secret at the specified location.
// path: Specifies the path of the secret.
func (a *Secrets) PostCubbyholePath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{cubbyhole_mount_path}/{path}"
	requestPath = strings.Replace(requestPath, "{"+"cubbyhole_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("cubbyhole")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpConfig
func (a *Secrets) PostGcpConfig(ctx context.Context, gcpConfigRequest GcpConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpConfigRotateRoot
func (a *Secrets) PostGcpConfigRotateRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/config/rotate-root"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpKeyRoleset
// roleset: Required. Name of the role set.
func (a *Secrets) PostGcpKeyRoleset(ctx context.Context, roleset string, gcpKeyRequest GcpKeyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/key/{roleset}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpKeyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpRolesetName
// name: Required. Name of the role.
func (a *Secrets) PostGcpRolesetName(ctx context.Context, name string, gcpRolesetRequest GcpRolesetRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{name}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpRolesetRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpRolesetNameRotate
// name: Name of the role.
func (a *Secrets) PostGcpRolesetNameRotate(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{name}/rotate"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpRolesetNameRotateKey
// name: Name of the role.
func (a *Secrets) PostGcpRolesetNameRotateKey(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{name}/rotate-key"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpRolesetRolesetKey
// roleset: Required. Name of the role set.
func (a *Secrets) PostGcpRolesetRolesetKey(ctx context.Context, roleset string, gcpRolesetKeyRequest GcpRolesetKeyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{roleset}/key"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpRolesetKeyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpRolesetRolesetToken
// roleset: Required. Name of the role set.
func (a *Secrets) PostGcpRolesetRolesetToken(ctx context.Context, roleset string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/roleset/{roleset}/token"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpStaticAccountName
// name: Required. Name to refer to this static account in Vault. Cannot be updated.
func (a *Secrets) PostGcpStaticAccountName(ctx context.Context, name string, gcpStaticAccountRequest GcpStaticAccountRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpStaticAccountRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpStaticAccountNameKey
// name: Required. Name of the static account.
func (a *Secrets) PostGcpStaticAccountNameKey(ctx context.Context, name string, gcpStaticAccountKeyRequest GcpStaticAccountKeyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}/key"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpStaticAccountKeyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpStaticAccountNameRotateKey
// name: Name of the account.
func (a *Secrets) PostGcpStaticAccountNameRotateKey(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}/rotate-key"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpStaticAccountNameToken
// name: Required. Name of the static account.
func (a *Secrets) PostGcpStaticAccountNameToken(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/static-account/{name}/token"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpTokenRoleset
// roleset: Required. Name of the role set.
func (a *Secrets) PostGcpTokenRoleset(ctx context.Context, roleset string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcp_mount_path}/token/{roleset}"
	requestPath = strings.Replace(requestPath, "{"+"gcp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"roleset"+"}", url.PathEscape(roleset), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsConfig Configure the GCP KMS secrets engine
func (a *Secrets) PostGcpkmsConfig(ctx context.Context, gcpkmsConfigRequest GcpkmsConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsDecryptKey Decrypt a ciphertext value using a named key
// key: Name of the key in Vault to use for decryption. This key must already exist in Vault and must map back to a Google Cloud KMS key.
func (a *Secrets) PostGcpkmsDecryptKey(ctx context.Context, key string, gcpkmsDecryptRequest GcpkmsDecryptRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/decrypt/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsDecryptRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsEncryptKey Encrypt a plaintext value using a named key
// key: Name of the key in Vault to use for encryption. This key must already exist in Vault and must map back to a Google Cloud KMS key.
func (a *Secrets) PostGcpkmsEncryptKey(ctx context.Context, key string, gcpkmsEncryptRequest GcpkmsEncryptRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/encrypt/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsEncryptRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsKeysConfigKey Configure the key in Vault
// key: Name of the key in Vault.
func (a *Secrets) PostGcpkmsKeysConfigKey(ctx context.Context, key string, gcpkmsKeysConfigRequest GcpkmsKeysConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/config/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsKeysConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsKeysDeregisterKey Deregister an existing key in Vault
// key: Name of the key to deregister in Vault. If the key exists in Google Cloud KMS, it will be left untouched.
func (a *Secrets) PostGcpkmsKeysDeregisterKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/deregister/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsKeysKey Interact with crypto keys in Vault and Google Cloud KMS
// key: Name of the key in Vault.
func (a *Secrets) PostGcpkmsKeysKey(ctx context.Context, key string, gcpkmsKeysRequest GcpkmsKeysRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsKeysRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsKeysRegisterKey Register an existing crypto key in Google Cloud KMS
// key: Name of the key to register in Vault. This will be the named used to refer to the underlying crypto key when encrypting or decrypting data.
func (a *Secrets) PostGcpkmsKeysRegisterKey(ctx context.Context, key string, gcpkmsKeysRegisterRequest GcpkmsKeysRegisterRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/register/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsKeysRegisterRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsKeysRotateKey Rotate a crypto key to a new primary version
// key: Name of the key to rotate. This key must already be registered with Vault and point to a valid Google Cloud KMS crypto key.
func (a *Secrets) PostGcpkmsKeysRotateKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/rotate/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsKeysTrimKey Delete old crypto key versions from Google Cloud KMS
// key: Name of the key in Vault.
func (a *Secrets) PostGcpkmsKeysTrimKey(ctx context.Context, key string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/keys/trim/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsReencryptKey Re-encrypt existing ciphertext data to a new version
// key: Name of the key to use for encryption. This key must already exist in Vault and Google Cloud KMS.
func (a *Secrets) PostGcpkmsReencryptKey(ctx context.Context, key string, gcpkmsReencryptRequest GcpkmsReencryptRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/reencrypt/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsReencryptRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsSignKey Signs a message or digest using a named key
// key: Name of the key in Vault to use for signing. This key must already exist in Vault and must map back to a Google Cloud KMS key.
func (a *Secrets) PostGcpkmsSignKey(ctx context.Context, key string, gcpkmsSignRequest GcpkmsSignRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/sign/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsSignRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostGcpkmsVerifyKey Verify a signature using a named key
// key: Name of the key in Vault to use for verification. This key must already exist in Vault and must map back to a Google Cloud KMS key.
func (a *Secrets) PostGcpkmsVerifyKey(ctx context.Context, key string, gcpkmsVerifyRequest GcpkmsVerifyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{gcpkms_mount_path}/verify/{key}"
	requestPath = strings.Replace(requestPath, "{"+"gcpkms_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("gcpkms")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key"+"}", url.PathEscape(key), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		gcpkmsVerifyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostKubernetesConfig
func (a *Secrets) PostKubernetesConfig(ctx context.Context, kubernetesConfigRequest KubernetesConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kubernetesConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostKubernetesCredsName
// name: Name of the Vault role
func (a *Secrets) PostKubernetesCredsName(ctx context.Context, name string, kubernetesCredsRequest KubernetesCredsRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kubernetesCredsRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostKubernetesRolesName
// name: Name of the role
func (a *Secrets) PostKubernetesRolesName(ctx context.Context, name string, kubernetesRolesRequest KubernetesRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{kubernetes_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"kubernetes_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("kubernetes")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kubernetesRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapConfig
func (a *Secrets) PostLdapConfig(ctx context.Context, ldapConfigRequest LdapConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		ldapConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapLibraryManageNameCheckIn Check service accounts in to the library.
// name: Name of the set.
func (a *Secrets) PostLdapLibraryManageNameCheckIn(ctx context.Context, name string, ldapLibraryManageCheckInRequest LdapLibraryManageCheckInRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library/manage/{name}/check-in"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		ldapLibraryManageCheckInRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapLibraryName Update a library set.
// name: Name of the set.
func (a *Secrets) PostLdapLibraryName(ctx context.Context, name string, ldapLibraryRequest LdapLibraryRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		ldapLibraryRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapLibraryNameCheckIn Check service accounts in to the library.
// name: Name of the set.
func (a *Secrets) PostLdapLibraryNameCheckIn(ctx context.Context, name string, ldapLibraryCheckInRequest LdapLibraryCheckInRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library/{name}/check-in"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		ldapLibraryCheckInRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapLibraryNameCheckOut Check a service account out from the library.
// name: Name of the set
func (a *Secrets) PostLdapLibraryNameCheckOut(ctx context.Context, name string, ldapLibraryCheckOutRequest LdapLibraryCheckOutRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/library/{name}/check-out"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		ldapLibraryCheckOutRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapRoleName
// name: Name of the role (lowercase)
func (a *Secrets) PostLdapRoleName(ctx context.Context, name string, ldapRoleRequest LdapRoleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		ldapRoleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapRotateRoleName
// name: Name of the static role
func (a *Secrets) PostLdapRotateRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/rotate-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapRotateRoot
func (a *Secrets) PostLdapRotateRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/rotate-root"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostLdapStaticRoleName
// name: Name of the role
func (a *Secrets) PostLdapStaticRoleName(ctx context.Context, name string, ldapStaticRoleRequest LdapStaticRoleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ldap_mount_path}/static-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"ldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		ldapStaticRoleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostMongodbatlasConfig Configure the  credentials that are used to manage Database Users.
func (a *Secrets) PostMongodbatlasConfig(ctx context.Context, mongodbatlasConfigRequest MongodbatlasConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		mongodbatlasConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostMongodbatlasCredsName Generate MongoDB Atlas Programmatic API from a specific Vault role.
// name: Name of the role
func (a *Secrets) PostMongodbatlasCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostMongodbatlasRolesName Manage the roles used to generate MongoDB Atlas Programmatic API Keys.
// name: Name of the Roles
func (a *Secrets) PostMongodbatlasRolesName(ctx context.Context, name string, mongodbatlasRolesRequest MongodbatlasRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{mongodbatlas_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"mongodbatlas_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("mongodbatlas")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		mongodbatlasRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostNomadConfigAccess
func (a *Secrets) PostNomadConfigAccess(ctx context.Context, nomadConfigAccessRequest NomadConfigAccessRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/config/access"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nomadConfigAccessRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostNomadConfigLease Configure the lease parameters for generated tokens
func (a *Secrets) PostNomadConfigLease(ctx context.Context, nomadConfigLeaseRequest NomadConfigLeaseRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/config/lease"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nomadConfigLeaseRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostNomadRoleName
// name: Name of the role
func (a *Secrets) PostNomadRoleName(ctx context.Context, name string, nomadRoleRequest NomadRoleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{nomad_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"nomad_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("nomad")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nomadRoleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapConfig
func (a *Secrets) PostOpenldapConfig(ctx context.Context, openldapConfigRequest OpenldapConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		openldapConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapLibraryManageNameCheckIn Check service accounts in to the library.
// name: Name of the set.
func (a *Secrets) PostOpenldapLibraryManageNameCheckIn(ctx context.Context, name string, openldapLibraryManageCheckInRequest OpenldapLibraryManageCheckInRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library/manage/{name}/check-in"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		openldapLibraryManageCheckInRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapLibraryName Update a library set.
// name: Name of the set.
func (a *Secrets) PostOpenldapLibraryName(ctx context.Context, name string, openldapLibraryRequest OpenldapLibraryRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		openldapLibraryRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapLibraryNameCheckIn Check service accounts in to the library.
// name: Name of the set.
func (a *Secrets) PostOpenldapLibraryNameCheckIn(ctx context.Context, name string, openldapLibraryCheckInRequest OpenldapLibraryCheckInRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library/{name}/check-in"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		openldapLibraryCheckInRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapLibraryNameCheckOut Check a service account out from the library.
// name: Name of the set
func (a *Secrets) PostOpenldapLibraryNameCheckOut(ctx context.Context, name string, openldapLibraryCheckOutRequest OpenldapLibraryCheckOutRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/library/{name}/check-out"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		openldapLibraryCheckOutRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapRoleName
// name: Name of the role (lowercase)
func (a *Secrets) PostOpenldapRoleName(ctx context.Context, name string, openldapRoleRequest OpenldapRoleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		openldapRoleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapRotateRoleName
// name: Name of the static role
func (a *Secrets) PostOpenldapRotateRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/rotate-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapRotateRoot
func (a *Secrets) PostOpenldapRotateRoot(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/rotate-root"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostOpenldapStaticRoleName
// name: Name of the role
func (a *Secrets) PostOpenldapStaticRoleName(ctx context.Context, name string, openldapStaticRoleRequest OpenldapStaticRoleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{openldap_mount_path}/static-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"openldap_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("openldap")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		openldapStaticRoleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiBundle
func (a *Secrets) PostPkiBundle(ctx context.Context, pkiBundleRequest PkiBundleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/bundle"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiBundleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiCert
func (a *Secrets) PostPkiCert(ctx context.Context, pkiCertRequest PkiCertRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/cert"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiCertRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiConfigAutoTidy
func (a *Secrets) PostPkiConfigAutoTidy(ctx context.Context, pkiConfigAutoTidyRequest PkiConfigAutoTidyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/auto-tidy"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiConfigAutoTidyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiConfigCa
func (a *Secrets) PostPkiConfigCa(ctx context.Context, pkiConfigCaRequest PkiConfigCaRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/ca"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiConfigCaRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiConfigCluster
func (a *Secrets) PostPkiConfigCluster(ctx context.Context, pkiConfigClusterRequest PkiConfigClusterRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/cluster"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiConfigClusterRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiConfigCrl
func (a *Secrets) PostPkiConfigCrl(ctx context.Context, pkiConfigCrlRequest PkiConfigCrlRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/crl"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiConfigCrlRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiConfigIssuers
func (a *Secrets) PostPkiConfigIssuers(ctx context.Context, pkiConfigIssuersRequest PkiConfigIssuersRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/issuers"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiConfigIssuersRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiConfigKeys
func (a *Secrets) PostPkiConfigKeys(ctx context.Context, pkiConfigKeysRequest PkiConfigKeysRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/keys"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiConfigKeysRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiConfigUrls
func (a *Secrets) PostPkiConfigUrls(ctx context.Context, pkiConfigUrlsRequest PkiConfigUrlsRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/config/urls"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiConfigUrlsRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIntermediateCrossSign
func (a *Secrets) PostPkiIntermediateCrossSign(ctx context.Context, pkiIntermediateCrossSignRequest PkiIntermediateCrossSignRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/intermediate/cross-sign"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIntermediateCrossSignRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIntermediateGenerateExported
// exported: Must be \"internal\", \"exported\" or \"kms\". If set to \"exported\", the generated private key will be returned. This is your *only* chance to retrieve the private key!
func (a *Secrets) PostPkiIntermediateGenerateExported(ctx context.Context, exported string, pkiIntermediateGenerateRequest PkiIntermediateGenerateRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/intermediate/generate/{exported}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"exported"+"}", url.PathEscape(exported), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIntermediateGenerateRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIntermediateSetSigned
func (a *Secrets) PostPkiIntermediateSetSigned(ctx context.Context, pkiIntermediateSetSignedRequest PkiIntermediateSetSignedRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/intermediate/set-signed"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIntermediateSetSignedRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiInternalExported
func (a *Secrets) PostPkiInternalExported(ctx context.Context, pkiInternalExportedRequest PkiInternalExportedRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/internal|exported"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiInternalExportedRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssueRole
// role: The desired role with configuration for this request
func (a *Secrets) PostPkiIssueRole(ctx context.Context, role string, pkiIssueRequest PkiIssueRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issue/{role}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssueRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefIssueRole
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
// role: The desired role with configuration for this request
func (a *Secrets) PostPkiIssuerIssuerRefIssueRole(ctx context.Context, issuerRef string, role string, pkiIssuerIssueRequest PkiIssuerIssueRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/issue/{role}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerIssueRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefResignCrls
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) PostPkiIssuerIssuerRefResignCrls(ctx context.Context, issuerRef string, pkiIssuerResignCrlsRequest PkiIssuerResignCrlsRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/resign-crls"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerResignCrlsRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefRevoke
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) PostPkiIssuerIssuerRefRevoke(ctx context.Context, issuerRef string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/revoke"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefSignIntermediate
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) PostPkiIssuerIssuerRefSignIntermediate(ctx context.Context, issuerRef string, pkiIssuerSignIntermediateRequest PkiIssuerSignIntermediateRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/sign-intermediate"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerSignIntermediateRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefSignRevocationList
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) PostPkiIssuerIssuerRefSignRevocationList(ctx context.Context, issuerRef string, pkiIssuerSignRevocationListRequest PkiIssuerSignRevocationListRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/sign-revocation-list"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerSignRevocationListRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefSignRole
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
// role: The desired role with configuration for this request
func (a *Secrets) PostPkiIssuerIssuerRefSignRole(ctx context.Context, issuerRef string, role string, pkiIssuerSignRequest PkiIssuerSignRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/sign/{role}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerSignRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefSignSelfIssued
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) PostPkiIssuerIssuerRefSignSelfIssued(ctx context.Context, issuerRef string, pkiIssuerSignSelfIssuedRequest PkiIssuerSignSelfIssuedRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/sign-self-issued"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerSignSelfIssuedRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefSignVerbatim
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) PostPkiIssuerIssuerRefSignVerbatim(ctx context.Context, issuerRef string, pkiIssuerSignVerbatimRequest PkiIssuerSignVerbatimRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/sign-verbatim"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerSignVerbatimRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerIssuerRefSignVerbatimRole
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
// role: The desired role with configuration for this request
func (a *Secrets) PostPkiIssuerIssuerRefSignVerbatimRole(ctx context.Context, issuerRef string, role string, pkiIssuerSignVerbatimRequest PkiIssuerSignVerbatimRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuer/{issuer_ref}/sign-verbatim/{role}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuerSignVerbatimRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuerRefDerPem
// issuerRef: Reference to a existing issuer; either \"default\" for the configured default issuer, an identifier or the name assigned to the issuer.
func (a *Secrets) PostPkiIssuerRefDerPem(ctx context.Context, issuerRef string, pkiDerPemRequest PkiDerPemRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/{issuer_ref}/der|/pem"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"issuer_ref"+"}", url.PathEscape(issuerRef), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiDerPemRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuersGenerateIntermediateExported
// exported: Must be \"internal\", \"exported\" or \"kms\". If set to \"exported\", the generated private key will be returned. This is your *only* chance to retrieve the private key!
func (a *Secrets) PostPkiIssuersGenerateIntermediateExported(ctx context.Context, exported string, pkiIssuersGenerateIntermediateRequest PkiIssuersGenerateIntermediateRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuers/generate/intermediate/{exported}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"exported"+"}", url.PathEscape(exported), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuersGenerateIntermediateRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiIssuersGenerateRootExported
// exported: Must be \"internal\", \"exported\" or \"kms\". If set to \"exported\", the generated private key will be returned. This is your *only* chance to retrieve the private key!
func (a *Secrets) PostPkiIssuersGenerateRootExported(ctx context.Context, exported string, pkiIssuersGenerateRootRequest PkiIssuersGenerateRootRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/issuers/generate/root/{exported}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"exported"+"}", url.PathEscape(exported), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiIssuersGenerateRootRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiJson
func (a *Secrets) PostPkiJson(ctx context.Context, pkiJsonRequest PkiJsonRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}//json"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiJsonRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiKeyKeyRef
// keyRef: Reference to key; either \"default\" for the configured default key, an identifier of a key, or the name assigned to the key.
func (a *Secrets) PostPkiKeyKeyRef(ctx context.Context, keyRef string, pkiKeyRequest PkiKeyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/key/{key_ref}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key_ref"+"}", url.PathEscape(keyRef), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiKeyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiKeysImport
func (a *Secrets) PostPkiKeysImport(ctx context.Context, pkiKeysImportRequest PkiKeysImportRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/keys/import"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiKeysImportRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiKms
func (a *Secrets) PostPkiKms(ctx context.Context, pkiKmsRequest PkiKmsRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/kms"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiKmsRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiOcsp
func (a *Secrets) PostPkiOcsp(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/ocsp"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRevoke
func (a *Secrets) PostPkiRevoke(ctx context.Context, pkiRevokeRequest PkiRevokeRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/revoke"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRevokeRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRevokeWithKey
func (a *Secrets) PostPkiRevokeWithKey(ctx context.Context, pkiRevokeWithKeyRequest PkiRevokeWithKeyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/revoke-with-key"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRevokeWithKeyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRolesName
// name: Name of the role
func (a *Secrets) PostPkiRolesName(ctx context.Context, name string, pkiRolesRequest PkiRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRootGenerateExported
// exported: Must be \"internal\", \"exported\" or \"kms\". If set to \"exported\", the generated private key will be returned. This is your *only* chance to retrieve the private key!
func (a *Secrets) PostPkiRootGenerateExported(ctx context.Context, exported string, pkiRootGenerateRequest PkiRootGenerateRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/root/generate/{exported}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"exported"+"}", url.PathEscape(exported), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRootGenerateRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRootReplace
func (a *Secrets) PostPkiRootReplace(ctx context.Context, pkiRootReplaceRequest PkiRootReplaceRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/root/replace"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRootReplaceRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRootRotateExported
// exported: Must be \"internal\", \"exported\" or \"kms\". If set to \"exported\", the generated private key will be returned. This is your *only* chance to retrieve the private key!
func (a *Secrets) PostPkiRootRotateExported(ctx context.Context, exported string, pkiRootRotateRequest PkiRootRotateRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/root/rotate/{exported}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"exported"+"}", url.PathEscape(exported), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRootRotateRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRootSignIntermediate
func (a *Secrets) PostPkiRootSignIntermediate(ctx context.Context, pkiRootSignIntermediateRequest PkiRootSignIntermediateRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/root/sign-intermediate"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRootSignIntermediateRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiRootSignSelfIssued
func (a *Secrets) PostPkiRootSignSelfIssued(ctx context.Context, pkiRootSignSelfIssuedRequest PkiRootSignSelfIssuedRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/root/sign-self-issued"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiRootSignSelfIssuedRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiSignRole
// role: The desired role with configuration for this request
func (a *Secrets) PostPkiSignRole(ctx context.Context, role string, pkiSignRequest PkiSignRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/sign/{role}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiSignRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiSignVerbatim
func (a *Secrets) PostPkiSignVerbatim(ctx context.Context, pkiSignVerbatimRequest PkiSignVerbatimRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/sign-verbatim"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiSignVerbatimRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiSignVerbatimRole
// role: The desired role with configuration for this request
func (a *Secrets) PostPkiSignVerbatimRole(ctx context.Context, role string, pkiSignVerbatimRequest PkiSignVerbatimRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/sign-verbatim/{role}"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiSignVerbatimRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiTidy
func (a *Secrets) PostPkiTidy(ctx context.Context, pkiTidyRequest PkiTidyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/tidy"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		pkiTidyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostPkiTidyCancel
func (a *Secrets) PostPkiTidyCancel(ctx context.Context, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{pki_mount_path}/tidy-cancel"
	requestPath = strings.Replace(requestPath, "{"+"pki_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("pki")), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostRabbitmqConfigConnection Configure the connection URI, username, and password to talk to RabbitMQ management HTTP API.
func (a *Secrets) PostRabbitmqConfigConnection(ctx context.Context, rabbitmqConfigConnectionRequest RabbitmqConfigConnectionRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/config/connection"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		rabbitmqConfigConnectionRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostRabbitmqConfigLease Configure the lease parameters for generated credentials
func (a *Secrets) PostRabbitmqConfigLease(ctx context.Context, rabbitmqConfigLeaseRequest RabbitmqConfigLeaseRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/config/lease"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		rabbitmqConfigLeaseRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostRabbitmqRolesName Manage the roles that can be created with this backend.
// name: Name of the role.
func (a *Secrets) PostRabbitmqRolesName(ctx context.Context, name string, rabbitmqRolesRequest RabbitmqRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{rabbitmq_mount_path}/roles/{name}"
	requestPath = strings.Replace(requestPath, "{"+"rabbitmq_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("rabbitmq")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		rabbitmqRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSecretConfig Configure backend level settings that are applied to every key in the key-value store.
func (a *Secrets) PostSecretConfig(ctx context.Context, kvConfigRequest KvConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kvConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSecretDataPath Write, Patch, Read, and Delete data in the Key-Value Store.
// path: Location of the secret.
func (a *Secrets) PostSecretDataPath(ctx context.Context, path string, kvDataRequest KvDataRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/data/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kvDataRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSecretDeletePath Marks one or more versions as deleted in the KV store.
// path: Location of the secret.
func (a *Secrets) PostSecretDeletePath(ctx context.Context, path string, kvDeleteRequest KvDeleteRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/delete/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kvDeleteRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSecretDestroyPath Permanently removes one or more versions in the KV store
// path: Location of the secret.
func (a *Secrets) PostSecretDestroyPath(ctx context.Context, path string, kvDestroyRequest KvDestroyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/destroy/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kvDestroyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSecretMetadataPath Configures settings for the KV store
// path: Location of the secret.
func (a *Secrets) PostSecretMetadataPath(ctx context.Context, path string, kvMetadataRequest KvMetadataRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/metadata/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kvMetadataRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSecretPath Pass-through secret storage to the storage backend, allowing you to read/write arbitrary data into secret storage.
// path: Location of the secret.
func (a *Secrets) PostSecretPath(ctx context.Context, path string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSecretUndeletePath Undeletes one or more versions from the KV store.
// path: Location of the secret.
func (a *Secrets) PostSecretUndeletePath(ctx context.Context, path string, kvUndeleteRequest KvUndeleteRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{secret_mount_path}/undelete/{path}"
	requestPath = strings.Replace(requestPath, "{"+"secret_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("secret")), -1)
	requestPath = strings.Replace(requestPath, "{"+"path"+"}", url.PathEscape(path), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		kvUndeleteRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshConfigCa Set the SSH private key used for signing certificates.
func (a *Secrets) PostSshConfigCa(ctx context.Context, sshConfigCaRequest SshConfigCaRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/config/ca"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshConfigCaRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshConfigZeroaddress Assign zero address as default CIDR block for select roles.
func (a *Secrets) PostSshConfigZeroaddress(ctx context.Context, sshConfigZeroaddressRequest SshConfigZeroaddressRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/config/zeroaddress"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshConfigZeroaddressRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshCredsRole Creates a credential for establishing SSH connection with the remote host.
// role: [Required] Name of the role
func (a *Secrets) PostSshCredsRole(ctx context.Context, role string, sshCredsRequest SshCredsRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/creds/{role}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshCredsRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshIssueRole
// role: The desired role with configuration for this request.
func (a *Secrets) PostSshIssueRole(ctx context.Context, role string, sshIssueRequest SshIssueRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/issue/{role}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshIssueRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshKeysKeyName Register a shared private key with Vault.
// keyName: [Required] Name of the key
func (a *Secrets) PostSshKeysKeyName(ctx context.Context, keyName string, sshKeysRequest SshKeysRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/keys/{key_name}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"key_name"+"}", url.PathEscape(keyName), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshKeysRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshLookup List all the roles associated with the given IP address.
func (a *Secrets) PostSshLookup(ctx context.Context, sshLookupRequest SshLookupRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/lookup"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshLookupRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshRolesRole Manage the 'roles' that can be created with this backend.
// role: [Required for all types] Name of the role being created.
func (a *Secrets) PostSshRolesRole(ctx context.Context, role string, sshRolesRequest SshRolesRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/roles/{role}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshRolesRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshSignRole Request signing an SSH key using a certain role with the provided details.
// role: The desired role with configuration for this request.
func (a *Secrets) PostSshSignRole(ctx context.Context, role string, sshSignRequest SshSignRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/sign/{role}"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)
	requestPath = strings.Replace(requestPath, "{"+"role"+"}", url.PathEscape(role), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshSignRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostSshVerify Validate the OTP provided by Vault SSH Agent.
func (a *Secrets) PostSshVerify(ctx context.Context, sshVerifyRequest SshVerifyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{ssh_mount_path}/verify"
	requestPath = strings.Replace(requestPath, "{"+"ssh_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("ssh")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		sshVerifyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTerraformConfig
func (a *Secrets) PostTerraformConfig(ctx context.Context, terraformConfigRequest TerraformConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/config"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		terraformConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTerraformCredsName Generate a Terraform Cloud or Enterprise API token from a specific Vault role.
// name: Name of the role
func (a *Secrets) PostTerraformCredsName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/creds/{name}"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTerraformRoleName
// name: Name of the role
func (a *Secrets) PostTerraformRoleName(ctx context.Context, name string, terraformRoleRequest TerraformRoleRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		terraformRoleRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTerraformRotateRoleName
// name: Name of the team or organization role
func (a *Secrets) PostTerraformRotateRoleName(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{terraform_mount_path}/rotate-role/{name}"
	requestPath = strings.Replace(requestPath, "{"+"terraform_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("terraform")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTotpCodeName Request time-based one-time use password or validate a password for a certain key .
// name: Name of the key.
func (a *Secrets) PostTotpCodeName(ctx context.Context, name string, totpCodeRequest TotpCodeRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{totp_mount_path}/code/{name}"
	requestPath = strings.Replace(requestPath, "{"+"totp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("totp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		totpCodeRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTotpKeysName Manage the keys that can be created with this backend.
// name: Name of the key.
func (a *Secrets) PostTotpKeysName(ctx context.Context, name string, totpKeysRequest TotpKeysRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{totp_mount_path}/keys/{name}"
	requestPath = strings.Replace(requestPath, "{"+"totp_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("totp")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		totpKeysRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitCacheConfig Configures a new cache of the specified size
func (a *Secrets) PostTransitCacheConfig(ctx context.Context, transitCacheConfigRequest TransitCacheConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/cache-config"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitCacheConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitDatakeyPlaintextName Generate a data key
// name: The backend key used for encrypting the data key
// plaintext: \"plaintext\" will return the key in both plaintext and ciphertext; \"wrapped\" will return the ciphertext only.
func (a *Secrets) PostTransitDatakeyPlaintextName(ctx context.Context, name string, plaintext string, transitDatakeyRequest TransitDatakeyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/datakey/{plaintext}/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)
	requestPath = strings.Replace(requestPath, "{"+"plaintext"+"}", url.PathEscape(plaintext), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitDatakeyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitDecryptName Decrypt a ciphertext value using a named key
// name: Name of the key
func (a *Secrets) PostTransitDecryptName(ctx context.Context, name string, transitDecryptRequest TransitDecryptRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/decrypt/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitDecryptRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitEncryptName Encrypt a plaintext value or a batch of plaintext blocks using a named key
// name: Name of the key
func (a *Secrets) PostTransitEncryptName(ctx context.Context, name string, transitEncryptRequest TransitEncryptRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/encrypt/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitEncryptRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitHash Generate a hash sum for input data
func (a *Secrets) PostTransitHash(ctx context.Context, transitHashRequest TransitHashRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/hash"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitHashRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitHashUrlalgorithm Generate a hash sum for input data
// urlalgorithm: Algorithm to use (POST URL parameter)
func (a *Secrets) PostTransitHashUrlalgorithm(ctx context.Context, urlalgorithm string, transitHashRequest TransitHashRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/hash/{urlalgorithm}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"urlalgorithm"+"}", url.PathEscape(urlalgorithm), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitHashRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitHmacName Generate an HMAC for input data using the named key
// name: The key to use for the HMAC function
func (a *Secrets) PostTransitHmacName(ctx context.Context, name string, transitHmacRequest TransitHmacRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/hmac/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitHmacRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitHmacNameUrlalgorithm Generate an HMAC for input data using the named key
// name: The key to use for the HMAC function
// urlalgorithm: Algorithm to use (POST URL parameter)
func (a *Secrets) PostTransitHmacNameUrlalgorithm(ctx context.Context, name string, urlalgorithm string, transitHmacRequest TransitHmacRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/hmac/{name}/{urlalgorithm}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)
	requestPath = strings.Replace(requestPath, "{"+"urlalgorithm"+"}", url.PathEscape(urlalgorithm), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitHmacRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitKeysName Managed named encryption keys
// name: Name of the key
func (a *Secrets) PostTransitKeysName(ctx context.Context, name string, transitKeysRequest TransitKeysRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitKeysRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitKeysNameConfig Configure a named encryption key
// name: Name of the key
func (a *Secrets) PostTransitKeysNameConfig(ctx context.Context, name string, transitKeysConfigRequest TransitKeysConfigRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}/config"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitKeysConfigRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitKeysNameImport Imports an externally-generated key into a new transit key
// name: The name of the key
func (a *Secrets) PostTransitKeysNameImport(ctx context.Context, name string, transitKeysImportRequest TransitKeysImportRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}/import"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitKeysImportRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitKeysNameImportVersion Imports an externally-generated key into an existing imported key
// name: The name of the key
func (a *Secrets) PostTransitKeysNameImportVersion(ctx context.Context, name string, transitKeysImportVersionRequest TransitKeysImportVersionRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}/import_version"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitKeysImportVersionRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitKeysNameRotate Rotate named encryption key
// name: Name of the key
func (a *Secrets) PostTransitKeysNameRotate(ctx context.Context, name string, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}/rotate"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		nil,       // request body
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitKeysNameTrim Trim key versions of a named key
// name: Name of the key
func (a *Secrets) PostTransitKeysNameTrim(ctx context.Context, name string, transitKeysTrimRequest TransitKeysTrimRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/keys/{name}/trim"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitKeysTrimRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitRandom Generate random bytes
func (a *Secrets) PostTransitRandom(ctx context.Context, transitRandomRequest TransitRandomRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/random"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitRandomRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitRandomSource Generate random bytes
// source: Which system to source random data from, ether \"platform\", \"seal\", or \"all\".
func (a *Secrets) PostTransitRandomSource(ctx context.Context, source string, transitRandomRequest TransitRandomRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/random/{source}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"source"+"}", url.PathEscape(source), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitRandomRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitRandomSourceUrlbytes Generate random bytes
// source: Which system to source random data from, ether \"platform\", \"seal\", or \"all\".
// urlbytes: The number of bytes to generate (POST URL parameter)
func (a *Secrets) PostTransitRandomSourceUrlbytes(ctx context.Context, source string, urlbytes string, transitRandomRequest TransitRandomRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/random/{source}/{urlbytes}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"source"+"}", url.PathEscape(source), -1)
	requestPath = strings.Replace(requestPath, "{"+"urlbytes"+"}", url.PathEscape(urlbytes), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitRandomRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitRandomUrlbytes Generate random bytes
// urlbytes: The number of bytes to generate (POST URL parameter)
func (a *Secrets) PostTransitRandomUrlbytes(ctx context.Context, urlbytes string, transitRandomRequest TransitRandomRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/random/{urlbytes}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"urlbytes"+"}", url.PathEscape(urlbytes), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitRandomRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitRestore Restore the named key
func (a *Secrets) PostTransitRestore(ctx context.Context, transitRestoreRequest TransitRestoreRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/restore"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitRestoreRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitRestoreName Restore the named key
// name: If set, this will be the name of the restored key.
func (a *Secrets) PostTransitRestoreName(ctx context.Context, name string, transitRestoreRequest TransitRestoreRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/restore/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitRestoreRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitRewrapName Rewrap ciphertext
// name: Name of the key
func (a *Secrets) PostTransitRewrapName(ctx context.Context, name string, transitRewrapRequest TransitRewrapRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/rewrap/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitRewrapRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitSignName Generate a signature for input data using the named key
// name: The key to use
func (a *Secrets) PostTransitSignName(ctx context.Context, name string, transitSignRequest TransitSignRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/sign/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitSignRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitSignNameUrlalgorithm Generate a signature for input data using the named key
// name: The key to use
// urlalgorithm: Hash algorithm to use (POST URL parameter)
func (a *Secrets) PostTransitSignNameUrlalgorithm(ctx context.Context, name string, urlalgorithm string, transitSignRequest TransitSignRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/sign/{name}/{urlalgorithm}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)
	requestPath = strings.Replace(requestPath, "{"+"urlalgorithm"+"}", url.PathEscape(urlalgorithm), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitSignRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitVerifyName Verify a signature or HMAC for input data created using the named key
// name: The key to use
func (a *Secrets) PostTransitVerifyName(ctx context.Context, name string, transitVerifyRequest TransitVerifyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/verify/{name}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitVerifyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}

// PostTransitVerifyNameUrlalgorithm Verify a signature or HMAC for input data created using the named key
// name: The key to use
// urlalgorithm: Hash algorithm to use (POST URL parameter)
func (a *Secrets) PostTransitVerifyNameUrlalgorithm(ctx context.Context, name string, urlalgorithm string, transitVerifyRequest TransitVerifyRequest, options ...RequestOption) (*Response[map[string]interface{}], error) {
	modifiers, err := requestOptionsToRequestModifiers(options)
	if err != nil {
		return nil, err
	}

	requestPath := "/v1/{transit_mount_path}/verify/{name}/{urlalgorithm}"
	requestPath = strings.Replace(requestPath, "{"+"transit_mount_path"+"}", url.PathEscape(modifiers.mountPathOr("transit")), -1)
	requestPath = strings.Replace(requestPath, "{"+"name"+"}", url.PathEscape(name), -1)
	requestPath = strings.Replace(requestPath, "{"+"urlalgorithm"+"}", url.PathEscape(urlalgorithm), -1)

	return sendStructuredRequestParseResponse[map[string]interface{}](
		ctx,
		a.client,
		http.MethodPost,
		requestPath,
		transitVerifyRequest,
		nil,       // request query parameters
		modifiers, // request modifiers (headers & callbacks)
	)
}